Typo correction: don't try to resolve anything about vars in their own initializer.

Author: rjmccall

include/swift/AST/LazyResolver.h

@@ -108,6 +108,72 @@ class LazyResolver {
                                          ExtensionDecl *protocolExtension) = 0;
 };
 
+/// An implementation of LazyResolver that delegates to another.
+class DelegatingLazyResolver : public LazyResolver {
+protected:
+  LazyResolver &Principal;
+public:
+  DelegatingLazyResolver(LazyResolver &principal) : Principal(principal) {}
+  ~DelegatingLazyResolver(); // v-table anchor
+
+  void resolveTypeWitness(const NormalProtocolConformance *conformance,
+                          AssociatedTypeDecl *assocType) override {
+    Principal.resolveTypeWitness(conformance, assocType);
+  }
+
+  void resolveWitness(const NormalProtocolConformance *conformance,
+                      ValueDecl *requirement) override {
+    Principal.resolveWitness(conformance, requirement);
+  }
+
+
+  Type resolveMemberType(DeclContext *dc, Type type, Identifier name) override {
+    return Principal.resolveMemberType(dc, type, name);
+  }
+
+  void resolveAccessibility(ValueDecl *VD) override {
+    Principal.resolveAccessibility(VD);
+  }
+
+  void resolveDeclSignature(ValueDecl *VD) override {
+    Principal.resolveDeclSignature(VD);
+  }
+
+  void resolveInheritanceClause(
+                llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl) override {
+    Principal.resolveInheritanceClause(decl);
+  }
+
+  void resolveSuperclass(ClassDecl *classDecl) override {
+    Principal.resolveSuperclass(classDecl);
+  }
+
+  void resolveRawType(EnumDecl *enumDecl) override {
+    Principal.resolveRawType(enumDecl);
+  }
+
+  void resolveInheritedProtocols(ProtocolDecl *protocol) override {
+    Principal.resolveInheritedProtocols(protocol);
+  }
+
+  void resolveExtension(ExtensionDecl *ext) override {
+    Principal.resolveExtension(ext);
+  }
+
+  void resolveImplicitConstructors(NominalTypeDecl *nominal) override {
+    Principal.resolveImplicitConstructors(nominal);
+  }
+
+  void resolveExternalDeclImplicitMembers(NominalTypeDecl *nominal) override {
+    Principal.resolveExternalDeclImplicitMembers(nominal);
+  }
+
+  bool isProtocolExtensionUsable(DeclContext *dc, Type type,
+                                 ExtensionDecl *protocolExtension) override {
+    return Principal.isProtocolExtensionUsable(dc, type, protocolExtension);
+  }
+};
+
 
 /// A class that can lazily load members from a serialized format.
 class alignas(void*) LazyMemberLoader {

lib/AST/ASTContext.cpp

@@ -48,6 +48,7 @@
 using namespace swift;
 
 LazyResolver::~LazyResolver() = default;
+DelegatingLazyResolver::~DelegatingLazyResolver() = default;
 void ModuleLoader::anchor() {}
 void ClangModuleLoader::anchor() {}
 

lib/Sema/TypeCheckNameLookup.cpp

@@ -464,6 +464,37 @@ static bool isPlausibleTypo(DeclRefKind refKind, DeclName typedName,
   return true;
 }
 
+static bool isLocInVarInit(TypeChecker &TC, VarDecl *var, SourceLoc loc) {
+  auto binding = var->getParentPatternBinding();
+  if (!binding || binding->isImplicit())
+    return false;
+
+  auto initRange = binding->getSourceRange();
+  return TC.Context.SourceMgr.rangeContainsTokenLoc(initRange, loc);
+}
+
+namespace {
+  class TypoCorrectionResolver : public DelegatingLazyResolver {
+    TypeChecker &TC() { return static_cast<TypeChecker&>(Principal); }
+    SourceLoc NameLoc;
+  public:
+    TypoCorrectionResolver(TypeChecker &TC, SourceLoc nameLoc)
+      : DelegatingLazyResolver(TC), NameLoc(nameLoc) {}
+
+    void resolveDeclSignature(ValueDecl *VD) override {
+      if (VD->isInvalid() || VD->hasType()) return;
+
+      // Don't process a variable if we're within its initializer.
+      if (auto var = dyn_cast<VarDecl>(VD)) {
+        if (isLocInVarInit(TC(), var, NameLoc))
+          return;
+      }
+
+      DelegatingLazyResolver::resolveDeclSignature(VD);
+    }
+  };
+}
+
 void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
                                         DeclName targetDeclName,
                                         SourceLoc nameLoc,
@@ -481,12 +512,8 @@ void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
 
     // Don't suggest a variable within its own initializer.
     if (auto var = dyn_cast<VarDecl>(decl)) {
-      if (auto binding = var->getParentPatternBinding()) {
-        if (!binding->isImplicit() &&
-            Context.SourceMgr.rangeContainsTokenLoc(binding->getSourceRange(),
-                                                    nameLoc))
-          return;
-      }
+      if (isLocInVarInit(*this, var, nameLoc))
+        return;
     }
 
     // Don't waste time computing edit distances that are more than
@@ -504,7 +531,8 @@ void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
     entries.insert(distance, std::move(decl));
   });
 
-  lookupVisibleDecls(consumer, DC, this, /*top level*/ true, nameLoc);
+  TypoCorrectionResolver resolver(*this, nameLoc);
+  lookupVisibleDecls(consumer, DC, &resolver, /*top level*/ true, nameLoc);
 
   // Impose a maximum distance from the best score.
   entries.filterMaxScoreRange(MaxCallEditDistanceFromBestCandidate);