ResolveEngine.kt is getting big

Maybe this is only my personal feeling, but I think ResolveEngine.kt becomes too big. It has already > 500 lines, and it’s growing.

As for now this file contains an object with multiple not-so-strictly coupled methods whose only similarity is their use case (and millions of millions of various utility functions). Some of them have even non consistent api, see:

fun resolveFieldExpr(fieldExpr: RsFieldExpr): List<RsCompositeElement>
fun resolveMethodCallExpr(call: RsMethodCallExpr): RsNamedElement?
fun resolveCallExpr(path: RustPath, element: RsPath, namespace: Namespace?): List<RsCompositeElement>
fun resolveStructExprField(structExpr: RsStructExpr, fieldName: String): List<RsNamedElement>
fun resolveUseGlob(ref: RsUseGlob): List<RsCompositeElement>
fun resolveModDecl(modDecl: RsModDeclItem): RsNamedElement?
fun resolveExternCrate(crate: RsExternCrateItem): RsNamedElement?
fun resolveLabel(label: RsLabel): RsLabelDecl?
fun resolveLifetime(lifetimeRef: RsLifetime): RsLifetimeDecl?

All these methods are named with pattern resolve{PSI element name} and so one would expect them to have also some pattern API, which they do not.

Maybe we should refactor resolve engine before it becomes total nightmare?

First of all, I think, three things have to be separated:

• resolving by name (string) - maybe this should be converted to project service? Also current API is pretty poor (or I don’t understand how to use it); how to resolve fully qualified name without knowing in which module it is?
• resolving PSI elements per se - maybe these ones should be converted to extension methods?
• utils

[matklad]

I’ve revamped the resolve engine 😃

The major change is that it is now based on scope processors, instead of sequences (instead of constructing a lazy Sequence, we pass a callback). This gives much nicer stacktraces, is actually more lazy and allows to implement stateful bits like shadowing in a more natural way. Some other improvements:

• Shadowing and multi resolve now work by design, and not by accident. No more random .firstOrNull calls.

• Completion and resolve now fully share code (as a bonus, we’ve got better completion for self:: and super:: without a separate completion contributror, and we’ve also got completion for lifetimes).

• Namespaces are pushed down during resolve, which allows to get rid of some hacks.

• String based resolve now works by creating a fake PSI element and resolving it.

We still have a zillion of methods and almost identical Reference classes though 😦

[matklad]

Yeah, I’d say the current state is better than the one from the issue creation time, and looks like @vlad20012 is going to refactor things further still!