Re-engineering clippy for Performance

While looking at reducing memory cost for compiling clippy (and reducing LintPasses in the process), I came upon an idea that could improve performance quite a bit. Currently, we're doing the same thing over and over – for example there must be at least eight macro checks for every expression visited, and we look at visibility and/or parents at least three times. If we could make clippy's architecture more streamy and cache intermediate results, we could reduce those checks and get some nice performance improvements.

Now you may be asking: If this is so great, why haven't we done it already? First, there's obviously a cost. In this new model, lints would be much more coupled. There would be only two passes (one ClippyEarlyPass and one ClippyLatePass – or perhaps we could even reduce this to one pass that implements both early and late pass?), which would implement the logic for all lints, calling out to specific checks. For example, we'd visit an expression, and only go into certain lint methods depending on the type. We could also cache some information (e.g. parent, macro expansion information) within the Pass object, lazily loaded when needed and reused while visiting the node.

Perhaps we could reduce our current lints to consistently named functions and have a script that generates the LintPass by collecting the existing functions and emitting calls. This would probably also reduce compile time – and the chance for errors because of missing passes.

Start by tracing ClippyEarlyPass and ClippyLatePass and how their lint methods are invoked during expression visits. Compare the repeated macro, visibility, and parent checks described in the issue, then assess where Pass-level caching could apply. Done would be a decided architecture and migration plan for consolidating passes and generating lint dispatch.