[NFC] ASTContext::getLazyResolver -> ASTContext::getLegacyGlobalTypeChecker

CodaFi · CodaFi · commit 2b08d1b83491 · 2019-11-05T14:44:41.000-08:00
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -101,6 +101,7 @@ namespace swift {
   class SourceManager;
   class ValueDecl;
   class DiagnosticEngine;
+  class TypeChecker;
   class TypeCheckerDebugConsumer;
   struct RawComment;
   class DocComment;
@@ -404,8 +405,13 @@ class ASTContext final {
   void setStatsReporter(UnifiedStatsReporter *stats);
 
 private:
+  friend class TypeChecker;
 
+  void installGlobalTypeChecker(TypeChecker *TC);
 public:
+  /// Retrieve the global \c TypeChecker instance associated with this context.
+  TypeChecker *getLegacyGlobalTypeChecker() const;
+
   /// getIdentifier - Return the uniqued and AST-Context-owned version of the
   /// specified string.
   Identifier getIdentifier(StringRef Str) const;
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -159,8 +159,8 @@ struct ASTContext::Implementation {
   /// The set of cleanups to be called when the ASTContext is destroyed.
   std::vector<std::function<void(void)>> Cleanups;
 
-  /// The last resolver.
-  LazyResolver *Resolver = nullptr;
+  /// A global type checker instance..
+  TypeChecker *Checker = nullptr;
 
   // FIXME: This is a StringMap rather than a StringSet because StringSet
   // doesn't allow passing in a pre-existing allocator.
@@ -479,8 +479,6 @@ ASTContext::Implementation::Implementation()
     : IdentifierTable(Allocator),
       TheSyntaxArena(new syntax::SyntaxArena()) {}
 ASTContext::Implementation::~Implementation() {
-  delete Resolver;
-
   for (auto &cleanup : Cleanups)
     cleanup();
 }
@@ -630,8 +628,9 @@ TypeChecker *ASTContext::getLegacyGlobalTypeChecker() const {
   return getImpl().Checker;
 }
 
-
-  getImpl().Resolver = resolver;
+void ASTContext::installGlobalTypeChecker(TypeChecker *TC) {
+  assert(!getImpl().Checker);
+  getImpl().Checker = TC;
 }
 
 /// getIdentifier - Return the uniqued and AST-Context-owned version of the
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -2889,8 +2889,8 @@ Type ValueDecl::getInterfaceType() const {
 
   // N.B. This assertion exists to catch new broken callers. It can be removed
   // with the LazyResolver when the time comes.
-  assert(ctx.getLazyResolver()
-         && "The lazy resolver must be registered to make semantic queries!");
+  assert(ctx.getLegacyGlobalTypeChecker()
+         && "The type checker must be installed to make semantic queries!");
 
   if (auto type =
           evaluateOrDefault(ctx.evaluator,
@@ -5686,8 +5686,9 @@ StaticSpellingKind AbstractStorageDecl::getCorrectStaticSpelling() const {
 
 llvm::TinyPtrVector<CustomAttr *> VarDecl::getAttachedPropertyWrappers() const {
   auto &ctx = getASTContext();
-  if (!ctx.getLazyResolver())
+  if (!ctx.getLegacyGlobalTypeChecker()) {
     return { };
+  }
 
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
@@ -6542,7 +6543,7 @@ ObjCSelector
 AbstractFunctionDecl::getObjCSelector(DeclName preferredName,
                                       bool skipIsObjCResolution) const {
   // FIXME: Forces computation of the Objective-C selector.
-  if (getASTContext().getLazyResolver() && !skipIsObjCResolution)
+  if (getASTContext().getLegacyGlobalTypeChecker() && !skipIsObjCResolution)
     (void)isObjC();
 
   // If there is an @objc attribute with a name, use that name.
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -1589,7 +1589,6 @@ bool DeclContext::lookupQualified(ArrayRef<NominalTypeDecl *> typeDecls,
   // Visit all of the nominal types we know about, discovering any others
   // we need along the way.
   auto &ctx = getASTContext();
-  auto typeResolver = ctx.getLazyResolver();
   bool wantProtocolMembers = (options & NL_ProtocolMembers);
   while (!stack.empty()) {
     auto current = stack.back();
@@ -1599,7 +1598,7 @@ bool DeclContext::lookupQualified(ArrayRef<NominalTypeDecl *> typeDecls,
       tracker->addUsedMember({current, member.getBaseName()},isLookupCascading);
 
     // Make sure we've resolved implicit members, if we need them.
-    if (typeResolver) {
+    if (ctx.getLegacyGlobalTypeChecker()) {
       current->synthesizeSemanticMembersIfNeeded(member);
       installPropertyWrapperMembersIfNeeded(current, member);
     }
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -1150,8 +1150,6 @@ CanType TypeBase::computeCanonicalType() {
     // If we haven't set a depth for this generic parameter, try to do so.
     // FIXME: This is a dreadful hack.
     if (gpDecl->getDepth() == GenericTypeParamDecl::InvalidDepth) {
-      auto resolver = gpDecl->getASTContext().getLazyResolver();
-      assert(resolver && "Need to resolve generic parameter depth");
       if (auto decl =
             gpDecl->getDeclContext()->getInnermostDeclarationDeclContext())
         if (auto valueDecl = decl->getAsGenericContext())
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -1643,7 +1643,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
         Importer(static_cast<ClangImporter *>(CurrDeclContext->getASTContext().
           getClangModuleLoader())),
         CompletionContext(CompletionContext) {
-    (void)createTypeChecker(Ctx);
+    (void)swift::createTypeChecker(Ctx);
 
     // Determine if we are doing code completion inside a static method.
     if (CurrDeclContext) {
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -3768,9 +3768,9 @@ bool swift::areGenericRequirementsSatisfied(
     const DeclContext *DC, GenericSignature sig,
     SubstitutionMap Substitutions, bool isExtension) {
 
-  TypeChecker &TC = createTypeChecker(DC->getASTContext());
+  auto *TC = DC->getASTContext().getLegacyGlobalTypeChecker();
   ConstraintSystemOptions Options;
-  ConstraintSystem CS(TC, const_cast<DeclContext *>(DC), Options);
+  ConstraintSystem CS(*TC, const_cast<DeclContext *>(DC), Options);
   auto Loc = CS.getConstraintLocator(nullptr);
 
   // For every requirement, add a constraint.
@@ -3793,9 +3793,10 @@ bool swift::areGenericRequirementsSatisfied(
 bool swift::canSatisfy(Type type1, Type type2, bool openArchetypes,
                        ConstraintKind kind, DeclContext *dc) {
   std::unique_ptr<TypeChecker> CreatedTC;
-  auto &TC = TypeChecker::createForContext(dc->getASTContext());
-  return TC.typesSatisfyConstraint(type1, type2, openArchetypes, kind, dc,
-                                   /*unwrappedIUO=*/nullptr);
+  auto *TC = dc->getASTContext().getLegacyGlobalTypeChecker();
+  assert(TC && "Must have type checker to make semantic query!");
+  return TC->typesSatisfyConstraint(type1, type2, openArchetypes, kind, dc,
+                                    /*unwrappedIUO=*/nullptr);
 }
 
 void swift::eraseOpenedExistentials(ConstraintSystem &CS, Expr *&expr) {
@@ -3841,8 +3842,9 @@ swift::resolveValueMember(DeclContext &DC, Type BaseTy, DeclName Name) {
   ResolvedMemberResult Result;
   std::unique_ptr<TypeChecker> CreatedTC;
   // If the current ast context has no type checker, create one for it.
-  auto &TC = TypeChecker::createForContext(DC.getASTContext());
-  ConstraintSystem CS(TC, &DC, None);
+  auto *TC = DC.getASTContext().getLegacyGlobalTypeChecker();
+  assert(TC && "Must have type checker to make global query!");
+  ConstraintSystem CS(*TC, &DC, None);
 
   // Look up all members of BaseTy with the given Name.
   MemberLookupResult LookupResult = CS.performMemberLookup(
diff --git a/lib/Sema/CSRanking.cpp b/lib/Sema/CSRanking.cpp
@@ -390,8 +390,8 @@ llvm::Expected<bool> CompareDeclSpecializationRequest::evaluate(
     Evaluator &eval, DeclContext *dc, ValueDecl *decl1, ValueDecl *decl2,
     bool isDynamicOverloadComparison) const {
   auto &C = decl1->getASTContext();
-  // FIXME: Remove dependency on the lazy resolver.
-  auto *tc = static_cast<TypeChecker *>(C.getLazyResolver());
+  // FIXME: Remove dependency on the global type checker.
+      auto *tc = C.getLegacyGlobalTypeChecker();
 
   if (C.LangOpts.DebugConstraintSolver) {
     auto &log = C.TypeCheckerDebug->getStream();
diff --git a/lib/Sema/DebuggerTestingTransform.cpp b/lib/Sema/DebuggerTestingTransform.cpp
@@ -218,7 +218,6 @@ class DebuggerTestingTransform : public ASTWalker {
     CheckExpectExpr->setThrows(false);
 
     // Create the closure.
-    TypeChecker &TC = TypeChecker::createForContext(Ctx);
     auto *Params = ParameterList::createEmpty(Ctx);
     auto *Closure = new (Ctx)
         ClosureExpr(Params, SourceLoc(), SourceLoc(), SourceLoc(), TypeLoc(),
@@ -238,6 +237,7 @@ class DebuggerTestingTransform : public ASTWalker {
     // TODO: typeCheckExpression() seems to assign types to everything here,
     // but may not be sufficient in some cases.
     Expr *FinalExpr = ClosureCall;
+    auto &TC = swift::createTypeChecker(Ctx);
     if (!TC.typeCheckExpression(FinalExpr, getCurrentDeclContext()))
       llvm::report_fatal_error("Could not type-check instrumentation");
 
diff --git a/lib/Sema/IDETypeCheckingRequests.cpp b/lib/Sema/IDETypeCheckingRequests.cpp
@@ -56,7 +56,7 @@ static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
   if (!ED->isConstrainedExtension())
     return true;
 
-  (void)TypeChecker::createForContext(DC->getASTContext());
+  (void)swift::createTypeChecker(DC->getASTContext());
   GenericSignature genericSig = ED->getGenericSignature();
   SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
       DC->getParentModule(), ED->getExtendedNominal());
diff --git a/lib/Sema/InstrumenterSupport.cpp b/lib/Sema/InstrumenterSupport.cpp
@@ -116,9 +116,9 @@ bool InstrumenterBase::doTypeCheckImpl(ASTContext &Ctx, DeclContext *DC,
   DiagnosticSuppression suppression(Ctx.Diags);
   ErrorGatherer errorGatherer(Ctx.Diags);
 
-  TypeChecker &TC = TypeChecker::createForContext(Ctx);
-
-  TC.typeCheckExpression(parsedExpr, DC);
+  auto *TC = Ctx.getLegacyGlobalTypeChecker();
+  assert(TC && "Must have type checker installed!");
+  TC->typeCheckExpression(parsedExpr, DC);
 
   if (parsedExpr) {
     ErrorFinder errorFinder;
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -1685,8 +1685,8 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
 
     
     {
-      auto *TC = static_cast<TypeChecker *>(ED->getASTContext().getLazyResolver());
-      assert(TC && "Must have a lazy resolver set");
+      auto *TC = ED->getASTContext().getLegacyGlobalTypeChecker();
+      assert(TC && "Must have a global type checker set");
       Expr *exprToCheck = prevValue;
       if (TC->typeCheckExpression(exprToCheck, ED, TypeLoc::withoutLoc(rawTy),
                                   CTP_EnumCaseRawValue)) {
diff --git a/lib/Sema/TypeCheckPropertyWrapper.cpp b/lib/Sema/TypeCheckPropertyWrapper.cpp
@@ -491,16 +491,16 @@ AttachedPropertyWrapperTypeRequest::evaluate(Evaluator &evaluator,
     return Type();
 
   ASTContext &ctx = var->getASTContext();
-  if (!ctx.getLazyResolver())
+  if (!ctx.getLegacyGlobalTypeChecker())
     return nullptr;
 
   auto resolution =
       TypeResolution::forContextual(var->getDeclContext());
   TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
   options |= TypeResolutionFlags::AllowUnboundGenerics;
 
-  auto &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
-  if (TypeChecker::validateType(tc.Context, customAttr->getTypeLoc(),
+  if (TypeChecker::validateType(var->getASTContext(),
+                                customAttr->getTypeLoc(),
                                 resolution, options))
     return ErrorType::get(ctx);
 
@@ -527,13 +527,13 @@ PropertyWrapperBackingPropertyTypeRequest::evaluate(
     return Type();
 
   ASTContext &ctx = var->getASTContext();
-  if (!ctx.getLazyResolver())
+  if (!ctx.getLegacyGlobalTypeChecker())
     return Type();
 
   // If there's an initializer of some sort, checking it will determine the
   // property wrapper type.
   unsigned index = binding->getPatternEntryIndexForVarDecl(var);
-  TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
+  TypeChecker &tc = *ctx.getLegacyGlobalTypeChecker();
   if (binding->isInitialized(index)) {
     // FIXME(InterfaceTypeRequest): Remove this.
     (void)var->getInterfaceType();
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -982,9 +982,8 @@ bool WitnessChecker::findBestWitness(
   bool anyFromUnconstrainedExtension;
   numViable = 0;
 
-  // FIXME: Remove dependency on the lazy resolver.
-  auto *TC = static_cast<TypeChecker *>(
-      requirement->getASTContext().getLazyResolver());
+  // FIXME: Remove dependency on the global type checker.
+  auto *TC = requirement->getASTContext().getLegacyGlobalTypeChecker();
   for (Attempt attempt = Regular; numViable == 0 && attempt != Done;
        attempt = static_cast<Attempt>(attempt + 1)) {
     SmallVector<ValueDecl *, 4> witnesses;
@@ -3372,7 +3371,7 @@ ResolveWitnessResult ConformanceChecker::resolveWitnessViaDerivation(
     return ResolveWitnessResult::ExplicitFailed;
 
   // Try to match the derived requirement.
-  auto *TC = static_cast<TypeChecker *>(getASTContext().getLazyResolver());
+  auto *TC = getASTContext().getLegacyGlobalTypeChecker();
   auto match = matchWitness(*TC, ReqEnvironmentCache, Proto, Conformance, DC,
                             requirement, derived);
   if (match.isViable()) {
@@ -4541,8 +4540,8 @@ static void diagnosePotentialWitness(NormalProtocolConformance *conformance,
   // Describe why the witness didn't satisfy the requirement.
   WitnessChecker::RequirementEnvironmentCache oneUseCache;
   auto dc = conformance->getDeclContext();
-  // FIXME: Remove dependency on the lazy resolver.
-  auto *TC = static_cast<TypeChecker *>(req->getASTContext().getLazyResolver());
+  // FIXME: Remove dependency on the global type checker.
+  auto *TC = req->getASTContext().getLegacyGlobalTypeChecker();
   auto match = matchWitness(*TC, oneUseCache, conformance->getProtocol(),
                             conformance, dc, req, witness);
   if (match.Kind == MatchKind::ExactMatch &&
@@ -5173,10 +5172,9 @@ swift::findWitnessedObjCRequirements(const ValueDecl *witness,
         if (accessorKind)
           witnessToMatch = cast<AccessorDecl>(witness)->getStorage();
 
-        auto lazyResolver = ctx.getLazyResolver();
-        assert(lazyResolver && "Need a type checker to match witnesses");
-        auto &tc = *static_cast<TypeChecker *>(lazyResolver);
-        if (matchWitness(tc, reqEnvCache, proto, *conformance,
+        auto *TC = ctx.getLegacyGlobalTypeChecker();
+        assert(TC && "Need a type checker to match witnesses");
+        if (matchWitness(*TC, reqEnvCache, proto, *conformance,
                          witnessToMatch->getDeclContext(), req,
                          const_cast<ValueDecl *>(witnessToMatch))
               .Kind == MatchKind::ExactMatch) {
diff --git a/lib/Sema/TypeCheckProtocolInference.cpp b/lib/Sema/TypeCheckProtocolInference.cpp
@@ -208,7 +208,7 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitnesses(
     // because those have to be explicitly declared on the type somewhere
     // so won't be affected by whatever answer inference comes up with.
     auto selfTy = extension->getSelfInterfaceType();
-    auto *tc = static_cast<TypeChecker *>(getASTContext().getLazyResolver());
+    auto *tc = getASTContext().getLegacyGlobalTypeChecker();
     for (const Requirement &reqt : extensionSig->getRequirements()) {
       switch (reqt.getKind()) {
       case RequirementKind::Conformance:
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
@@ -1867,7 +1867,7 @@ static Expr* constructCallToSuperInit(ConstructorDecl *ctor,
   if (ctor->hasThrows())
     r = new (Context) TryExpr(SourceLoc(), r, Type(), /*implicit=*/true);
 
-  TypeChecker &tc = *static_cast<TypeChecker *>(Context.getLazyResolver());
+  TypeChecker &tc = *Context.getLegacyGlobalTypeChecker();
   DiagnosticSuppression suppression(tc.Diags);
   auto resultTy =
       tc.typeCheckExpression(r, ctor, TypeLoc(), CTP_Unused,
@@ -1881,7 +1881,7 @@ static Expr* constructCallToSuperInit(ConstructorDecl *ctor,
 /// Check a super.init call.
 ///
 /// \returns true if an error occurred.
-static bool checkSuperInit(TypeChecker &tc, ConstructorDecl *fromCtor, 
+static bool checkSuperInit(ConstructorDecl *fromCtor,
                            ApplyExpr *apply, bool implicitlyGenerated) {
   // Make sure we are referring to a designated initializer.
   auto otherCtorRef = dyn_cast<OtherConstructorDeclRefExpr>(
@@ -1895,8 +1895,9 @@ static bool checkSuperInit(TypeChecker &tc, ConstructorDecl *fromCtor,
       auto selfTy = fromCtor->getDeclContext()->getSelfInterfaceType();
       if (auto classTy = selfTy->getClassOrBoundGenericClass()) {
         assert(classTy->getSuperclass());
-        tc.diagnose(apply->getArg()->getLoc(), diag::chain_convenience_init,
-                    classTy->getSuperclass());
+        auto &Diags = fromCtor->getASTContext().Diags;
+        Diags.diagnose(apply->getArg()->getLoc(), diag::chain_convenience_init,
+                       classTy->getSuperclass());
         ctor->diagnose(diag::convenience_init_here);
       }
     }
@@ -1934,7 +1935,7 @@ static bool checkSuperInit(TypeChecker &tc, ConstructorDecl *fromCtor,
       bool treatUsableFromInlineAsPublic;
       std::tie(fragileKind, treatUsableFromInlineAsPublic) =
           TypeChecker::getFragileFunctionKind(fromCtor);
-      tc.diagnoseInlinableDeclRef(
+      TypeChecker::diagnoseInlinableDeclRef(
           fromCtor->getLoc(), ctor, fromCtor, fragileKind,
           treatUsableFromInlineAsPublic);
     }
@@ -1957,7 +1958,6 @@ static void checkClassConstructorBody(ClassDecl *classDecl,
                                       ConstructorDecl *ctor,
                                       BraceStmt *body) {
   ASTContext &ctx = classDecl->getASTContext();
-  TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
   bool wantSuperInitCall = false;
   bool isDelegating = false;
   ApplyExpr *initExpr = nullptr;
@@ -1968,7 +1968,7 @@ static void checkClassConstructorBody(ClassDecl *classDecl,
     break;
 
   case ConstructorDecl::BodyInitKind::Chained:
-    checkSuperInit(tc, ctor, initExpr, false);
+    checkSuperInit(ctor, initExpr, false);
 
     /// A convenience initializer cannot chain to a superclass constructor.
     if (ctor->isConvenienceInit()) {
@@ -2038,7 +2038,7 @@ static void checkClassConstructorBody(ClassDecl *classDecl,
 
   FindOtherConstructorRef finder;
   SuperInitCall->walk(finder);
-  if (!checkSuperInit(tc, ctor, finder.Found, true)) {
+  if (!checkSuperInit(ctor, finder.Found, true)) {
     // Store the super.init expression within the constructor declaration
     // to be emitted during SILGen.
     ctor->setSuperInitCall(SuperInitCall);
@@ -2061,7 +2061,7 @@ TypeCheckFunctionBodyUntilRequest::evaluate(Evaluator &evaluator,
     ctx.Stats->getFrontendCounters().NumFunctionsTypechecked++;
 
   Optional<FunctionBodyTimer> timer;
-  TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
+  TypeChecker &tc = *ctx.getLegacyGlobalTypeChecker();
   if (tc.DebugTimeFunctionBodies || tc.WarnLongFunctionBodies)
     timer.emplace(AFD, tc.DebugTimeFunctionBodies, tc.WarnLongFunctionBodies);
 
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
