Merge pull request #28030 from CodaFi/unit-normals

CodaFi · web-flow · commit a73c1f4293e3 · 2019-11-01T19:41:26.000-07:00
[NFC] Plot The Demise of LazyResolver
diff --git a/include/swift/AST/LazyResolver.h b/include/swift/AST/LazyResolver.h
@@ -53,9 +53,6 @@ class LazyResolver {
   virtual void resolveWitness(const NormalProtocolConformance *conformance,
                               ValueDecl *requirement) = 0;
 
-  /// Resolve any implicitly-declared constructors within the given nominal.
-  virtual void resolveImplicitConstructors(NominalTypeDecl *nominal) = 0;
-
   /// Resolve an implicitly-generated member with the given name.
   virtual void resolveImplicitMember(NominalTypeDecl *nominal, DeclName member) = 0;
 };
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -1572,9 +1572,6 @@ bool DeclContext::lookupQualified(ArrayRef<NominalTypeDecl *> typeDecls,
 
     // Make sure we've resolved implicit members, if we need them.
     if (typeResolver) {
-      if (member.getBaseName() == DeclBaseName::createConstructor())
-        typeResolver->resolveImplicitConstructors(current);
-
       typeResolver->resolveImplicitMember(current, member);
     }
 
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -1077,6 +1077,9 @@ void TypeChecker::synthesizeMemberForLookup(NominalTypeDecl *target,
                                             DeclName member) {
   auto baseName = member.getBaseName();
 
+  if (baseName == DeclBaseName::createConstructor())
+    addImplicitConstructors(target);
+
   // Checks whether the target conforms to the given protocol. If the
   // conformance is incomplete, force the conformance.
   //
@@ -1097,7 +1100,7 @@ void TypeChecker::synthesizeMemberForLookup(NominalTypeDecl *target,
     if (auto *conformance = dyn_cast<NormalProtocolConformance>(
             ref.getConcrete()->getRootConformance())) {
       if (conformance->getState() == ProtocolConformanceState::Incomplete) {
-        checkConformance(conformance);
+        TypeChecker::checkConformance(conformance);
       }
     }
 
diff --git a/lib/Sema/DerivedConformanceCodable.cpp b/lib/Sema/DerivedConformanceCodable.cpp
@@ -370,10 +370,7 @@ static EnumDecl *synthesizeCodingKeysEnum(DerivedConformance &derived) {
     return nullptr;
 
   // Forcibly derive conformance to CodingKey.
-  //
-  // FIXME: Drop the dependency on the type checker.
-  auto *tc = static_cast<TypeChecker *>(C.getLazyResolver());
-  tc->checkConformancesInContext(enumDecl, enumDecl);
+  TypeChecker::checkConformancesInContext(enumDecl, enumDecl);
 
   // Add to the type.
   target->addMember(enumDecl);
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -4450,9 +4450,6 @@ EmittedMembersRequest::evaluate(Evaluator &evaluator,
 
   auto &Context = CD->getASTContext();
 
-  // FIXME: Remove TypeChecker dependencies below
-  auto &TC = *(TypeChecker *) Context.getLazyResolver();
-
   // We need to add implicit initializers because they
   // affect vtable layout.
   TypeChecker::addImplicitConstructors(CD);
@@ -4469,7 +4466,7 @@ EmittedMembersRequest::evaluate(Evaluator &evaluator,
     auto conformance = ref.getConcrete();
     if (conformance->getDeclContext() == CD &&
         conformance->getState() == ProtocolConformanceState::Incomplete) {
-      TC.checkConformance(conformance->getRootNormalConformance());
+      TypeChecker::checkConformance(conformance->getRootNormalConformance());
     }
   };
 
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -981,8 +981,9 @@ bool WitnessChecker::findBestWitness(
   bool anyFromUnconstrainedExtension;
   numViable = 0;
 
-  // FIXME: Remove dependnecy on the lazy resolver.
-  auto *TC = static_cast<TypeChecker *>(getASTContext().getLazyResolver());
+  // FIXME: Remove dependency on the lazy resolver.
+  auto *TC = static_cast<TypeChecker *>(
+      requirement->getASTContext().getLazyResolver());
   for (Attempt attempt = Regular; numViable == 0 && attempt != Done;
        attempt = static_cast<Attempt>(attempt + 1)) {
     SmallVector<ValueDecl *, 4> witnesses;
@@ -1265,7 +1266,7 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
 /// having this wrapper can help issue a fixit that inserts protocol stubs from
 /// multiple protocols under checking.
 class swift::MultiConformanceChecker {
-  TypeChecker &TC;
+  ASTContext &Context;
   llvm::SmallVector<ValueDecl*, 16> UnsatisfiedReqs;
   llvm::SmallVector<ConformanceChecker, 4> AllUsedCheckers;
   llvm::SmallVector<NormalProtocolConformance*, 4> AllConformances;
@@ -1279,9 +1280,9 @@ class swift::MultiConformanceChecker {
   /// Determine whether the given requirement was left unsatisfied.
   bool isUnsatisfiedReq(NormalProtocolConformance *conformance, ValueDecl *req);
 public:
-  MultiConformanceChecker(TypeChecker &TC): TC(TC){}
+  MultiConformanceChecker(ASTContext &ctx) : Context(ctx) {}
 
-  ASTContext &getASTContext() const { return TC.Context; }
+  ASTContext &getASTContext() const { return Context; }
 
   /// Add a conformance into the batched checker.
   void addConformance(NormalProtocolConformance *conformance) {
@@ -4221,7 +4222,7 @@ operator()(CanType dependentType, Type conformingReplacementType,
 }
 
 void TypeChecker::checkConformance(NormalProtocolConformance *conformance) {
-  MultiConformanceChecker checker(*this);
+  MultiConformanceChecker checker(conformance->getProtocol()->getASTContext());
   checker.addConformance(conformance);
   checker.checkAllConformances();
 }
@@ -4522,10 +4523,8 @@ static bool shouldWarnAboutPotentialWitness(
 }
 
 /// Diagnose a potential witness.
-static void diagnosePotentialWitness(TypeChecker &tc,
-                                     NormalProtocolConformance *conformance,
-                                     ValueDecl *req,
-                                     ValueDecl *witness,
+static void diagnosePotentialWitness(NormalProtocolConformance *conformance,
+                                     ValueDecl *req, ValueDecl *witness,
                                      AccessLevel access) {
   auto proto = cast<ProtocolDecl>(req->getDeclContext());
 
@@ -4538,7 +4537,9 @@ static void diagnosePotentialWitness(TypeChecker &tc,
   // Describe why the witness didn't satisfy the requirement.
   WitnessChecker::RequirementEnvironmentCache oneUseCache;
   auto dc = conformance->getDeclContext();
-  auto match = matchWitness(tc, oneUseCache, conformance->getProtocol(),
+  // FIXME: Remove dependency on the lazy resolver.
+  auto *TC = static_cast<TypeChecker *>(req->getASTContext().getLazyResolver());
+  auto match = matchWitness(*TC, oneUseCache, conformance->getProtocol(),
                             conformance, dc, req, witness);
   if (match.Kind == MatchKind::ExactMatch &&
       req->isObjC() && !witness->isObjC()) {
@@ -4819,7 +4820,8 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
                                                &diagnostics);
 
   // The conformance checker bundle that checks all conformances in the context.
-  MultiConformanceChecker groupChecker(*this);
+  auto &Context = dc->getASTContext();
+  MultiConformanceChecker groupChecker(Context);
 
   bool anyInvalid = false;
   for (auto conformance : conformances) {
@@ -4899,11 +4901,11 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
       auto diagID = differentlyConditional
                         ? diag::redundant_conformance_adhoc_conditional
                         : diag::redundant_conformance_adhoc;
-      diagnose(diag.Loc, diagID, dc->getDeclaredInterfaceType(),
-               diag.Protocol->getName(),
-               existingModule->getName() ==
-                   extendedNominal->getParentModule()->getName(),
-               existingModule->getName());
+      Context.Diags.diagnose(diag.Loc, diagID, dc->getDeclaredInterfaceType(),
+                             diag.Protocol->getName(),
+                             existingModule->getName() ==
+                                 extendedNominal->getParentModule()->getName(),
+                             existingModule->getName());
 
       // Complain about any declarations in this extension whose names match
       // a requirement in that protocol.
@@ -4928,18 +4930,18 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
           if (valueIsType != requirementIsType)
             continue;
 
-          diagnose(value, diag::redundant_conformance_witness_ignored,
-                   value->getDescriptiveKind(), value->getFullName(),
-                   diag.Protocol->getFullName());
+          value->diagnose(diag::redundant_conformance_witness_ignored,
+                          value->getDescriptiveKind(), value->getFullName(),
+                          diag.Protocol->getFullName());
           break;
         }
       }
     } else {
       auto diagID = differentlyConditional
                         ? diag::redundant_conformance_conditional
                         : diag::redundant_conformance;
-      diagnose(diag.Loc, diagID, dc->getDeclaredInterfaceType(),
-               diag.Protocol->getName());
+      Context.Diags.diagnose(diag.Loc, diagID, dc->getDeclaredInterfaceType(),
+                             diag.Protocol->getName());
     }
 
     // Special case: explain that 'RawRepresentable' conformance
@@ -4951,18 +4953,19 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
                                                          diag.Protocol) &&
           enumDecl->hasRawType() &&
           enumDecl->getInherited()[0].getSourceRange().isValid()) {
-        diagnose(enumDecl->getInherited()[0].getSourceRange().Start,
-                 diag::enum_declares_rawrep_with_raw_type,
-                 dc->getDeclaredInterfaceType(), enumDecl->getRawType());
+        auto inheritedLoc = enumDecl->getInherited()[0].getSourceRange().Start;
+        Context.Diags.diagnose(
+            inheritedLoc, diag::enum_declares_rawrep_with_raw_type,
+            dc->getDeclaredInterfaceType(), enumDecl->getRawType());
         continue;
       }
     }
 
-    diagnose(existingDecl, diag::declared_protocol_conformance_here,
-             dc->getDeclaredInterfaceType(),
-             static_cast<unsigned>(diag.ExistingKind),
-             diag.Protocol->getName(),
-             diag.ExistingExplicitProtocol->getName());
+    existingDecl->diagnose(diag::declared_protocol_conformance_here,
+                           dc->getDeclaredInterfaceType(),
+                           static_cast<unsigned>(diag.ExistingKind),
+                           diag.Protocol->getName(),
+                           diag.ExistingExplicitProtocol->getName());
   }
 
   // If there were any unsatisfied requirements, check whether there
@@ -5034,8 +5037,7 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
           bool diagnosed = false;
           for (auto conformance : conformances) {
             if (conformance->getProtocol() == req->getDeclContext()) {
-              diagnosePotentialWitness(*this,
-                                       conformance->getRootNormalConformance(),
+              diagnosePotentialWitness(conformance->getRootNormalConformance(),
                                        req, value, defaultAccess);
               diagnosed = true;
               break;
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
@@ -293,10 +293,10 @@ static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC)
     for (unsigned i = 0; i != TC.ConformanceContexts.size(); ++i) {
       auto decl = TC.ConformanceContexts[i];
       if (auto *ext = dyn_cast<ExtensionDecl>(decl))
-        TC.checkConformancesInContext(ext, ext);
+        TypeChecker::checkConformancesInContext(ext, ext);
       else {
         auto *ntd = cast<NominalTypeDecl>(decl);
-        TC.checkConformancesInContext(ntd, ntd);
+        TypeChecker::checkConformancesInContext(ntd, ntd);
 
         // Finally, we can check classes for missing initializers.
         if (auto *classDecl = dyn_cast<ClassDecl>(ntd))
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -1015,10 +1015,6 @@ class TypeChecker final : public LazyResolver {
   static Type checkReferenceOwnershipAttr(VarDecl *D, Type interfaceType,
                                           ReferenceOwnershipAttr *attr);
 
-  virtual void resolveImplicitConstructors(NominalTypeDecl *nominal) override {
-    addImplicitConstructors(nominal);
-  }
-
   virtual void resolveImplicitMember(NominalTypeDecl *nominal, DeclName member) override {
     synthesizeMemberForLookup(nominal, member);
   }
@@ -1524,11 +1520,11 @@ class TypeChecker final : public LazyResolver {
   };
 
   /// Completely check the given conformance.
-  void checkConformance(NormalProtocolConformance *conformance);
+  static void checkConformance(NormalProtocolConformance *conformance);
 
   /// Check all of the conformances in the given context.
-  void checkConformancesInContext(DeclContext *dc,
-                                  IterableDeclContext *idc);
+  static void checkConformancesInContext(DeclContext *dc,
+                                         IterableDeclContext *idc);
 
   /// Check that the type of the given property conforms to NSCopying.
   static ProtocolConformanceRef checkConformanceToNSCopying(VarDecl *var);

Original file line number	Diff line number	Diff line change
`@@ -1572,9 +1572,6 @@ bool DeclContext::lookupQualified(ArrayRef<NominalTypeDecl *> typeDecls,`
`1572`	`1572`
`1573`	`1573`	`// Make sure we've resolved implicit members, if we need them.`
`1574`	`1574`	`if (typeResolver) {`
`1575`		`- if (member.getBaseName() == DeclBaseName::createConstructor())`
`1576`		`- typeResolver->resolveImplicitConstructors(current);`
`1577`		`-`
`1578`	`1575`	`typeResolver->resolveImplicitMember(current, member);`
`1579`	`1576`	`}`
`1580`	`1577`