Sema: Remove TypoCorrectionResolver

With the previous changes, validating a property while
type checking its initializer is no longer a fatal error.

This means we don't have to do anything special when
validating typo correction candidates, so we can get rid
of the TypoCorrectionResolver. This means there is now
only one subclass of LazyResolver, the TypeChecker itself.

Author: slavapestov

include/swift/AST/LazyResolver.h

@@ -101,71 +101,6 @@ class LazyResolver {
                                    DeclContext *dc) = 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);
-  }
-
-  void resolveAccessControl(ValueDecl *VD) override {
-    Principal.resolveAccessControl(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 bindExtension(ExtensionDecl *ext) override {
-    Principal.bindExtension(ext);
-  }
-
-  void resolveExtension(ExtensionDecl *ext) override {
-    Principal.resolveExtension(ext);
-  }
-
-  void resolveImplicitConstructors(NominalTypeDecl *nominal) override {
-    Principal.resolveImplicitConstructors(nominal);
-  }
-
-  void resolveImplicitMember(NominalTypeDecl *nominal, DeclName member) override {
-    Principal.resolveImplicitMember(nominal, member);
-  }
-
-  void markConformanceUsed(ProtocolConformanceRef conformance,
-                           DeclContext *dc) override {
-    return Principal.markConformanceUsed(conformance, dc);
-  }
-};
-
 class LazyMemberLoader;
 
 /// Context data for lazy deserialization.

lib/AST/ASTContext.cpp

@@ -67,7 +67,6 @@ STATISTIC(NumCollapsedSpecializedProtocolConformances,
 #define SWIFT_GSB_EXPENSIVE_ASSERTIONS 0
 
 LazyResolver::~LazyResolver() = default;
-DelegatingLazyResolver::~DelegatingLazyResolver() = default;
 void ModuleLoader::anchor() {}
 void ClangModuleLoader::anchor() {}
 

lib/Sema/TypeCheckNameLookup.cpp

@@ -539,28 +539,6 @@ static bool isLocInVarInit(TypeChecker &TC, VarDecl *var, SourceLoc loc) {
   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->hasInterfaceType()) 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);
-    }
-  };
-} // end anonymous namespace
-
 void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
                                         Type baseTypeOrNull,
                                         DeclName targetDeclName,
@@ -608,12 +586,11 @@ void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
     entries.insert(distance, std::move(decl));
   });
 
-  TypoCorrectionResolver resolver(*this, nameLoc);
   if (baseTypeOrNull) {
-    lookupVisibleMemberDecls(consumer, baseTypeOrNull, DC, &resolver,
+    lookupVisibleMemberDecls(consumer, baseTypeOrNull, DC, this,
                              /*include instance members*/ true, gsb);
   } else {
-    lookupVisibleDecls(consumer, DC, &resolver, /*top level*/ true, nameLoc);
+    lookupVisibleDecls(consumer, DC, this, /*top level*/ true, nameLoc);
   }
 
   // Impose a maximum distance from the best score.