Sema: Peel off more code from the TypeChecker instance

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -4090,7 +4090,7 @@ namespace {
         method = func;
       } else if (auto var = dyn_cast<VarDecl>(foundDecl)) {
         // Properties.
-        maybeAddAccessorsToStorage(tc, var);
+        maybeAddAccessorsToStorage(var);
 
         // If this isn't a property on a type, complain.
         if (!var->getDeclContext()->isTypeContext()) {

lib/Sema/CodeSynthesis.cpp

@@ -620,10 +620,8 @@ static bool checkConformanceToNSCopying(ASTContext &ctx, VarDecl *var,
   auto dc = var->getDeclContext();
   auto proto = getNSCopyingProtocol(ctx, dc);
 
-  // FIXME: Remove this usage of TypeChecker
-  auto &TC = *(TypeChecker *) ctx.getLazyResolver();
-  if (!proto || !TC.conformsToProtocol(type, proto, dc, None)) {
-    TC.diagnose(var->getLoc(), diag::nscopying_doesnt_conform);
+  if (!proto || !TypeChecker::conformsToProtocol(type, proto, dc, None)) {
+    ctx.Diags.diagnose(var->getLoc(), diag::nscopying_doesnt_conform);
     return true;
   }
   return false;
@@ -1337,7 +1335,9 @@ static void synthesizeLazySetterBody(AbstractFunctionDecl *fn, void *context) {
                                          underlyingStorage, ctx);
 }
 
-void TypeChecker::completeLazyVarImplementation(VarDecl *VD) {
+void swift::completeLazyVarImplementation(VarDecl *VD) {
+  auto &Context = VD->getASTContext();
+
   assert(VD->getAttrs().hasAttribute<LazyAttr>());
   assert(VD->getReadImpl() == ReadImplKind::Get);
   assert(VD->getWriteImpl() == WriteImplKind::Set);
@@ -1406,13 +1406,13 @@ static bool wouldBeCircularSynthesis(AbstractStorageDecl *storage,
 void swift::triggerAccessorSynthesis(TypeChecker &TC,
                                      AbstractStorageDecl *storage) {
   auto VD = dyn_cast<VarDecl>(storage);
-  maybeAddAccessorsToStorage(TC, storage);
+  maybeAddAccessorsToStorage(storage);
 
   // Synthesize accessors for lazy, all checking already been performed.
   bool lazy = false;
   if (VD && VD->getAttrs().hasAttribute<LazyAttr>() && !VD->isStatic() &&
       !VD->getGetter()->hasBody()) {
-    TC.completeLazyVarImplementation(VD);
+    completeLazyVarImplementation(VD);
     lazy = true;
   }
 
@@ -1466,11 +1466,12 @@ static void maybeAddAccessorsToLazyVariable(VarDecl *var, ASTContext &ctx) {
 /// Note that the parser synthesizes accessors in some cases:
 ///   - it synthesizes a getter and setter for an observing property
 ///   - it synthesizes a setter for get+mutableAddress
-void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
-                                       AbstractStorageDecl *storage) {
+void swift::maybeAddAccessorsToStorage(AbstractStorageDecl *storage) {
+  auto &ctx = storage->getASTContext();
+
   // Lazy properties require special handling.
   if (storage->getAttrs().hasAttribute<LazyAttr>()) {
-    maybeAddAccessorsToLazyVariable(cast<VarDecl>(storage), TC.Context);
+    maybeAddAccessorsToLazyVariable(cast<VarDecl>(storage), ctx);
     return;
   }
 
@@ -1487,7 +1488,7 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
   if (!dc->isTypeContext()) {
     // dynamic globals need accessors.
     if (dc->isModuleScopeContext() && storage->isNativeDynamic()) {
-      addTrivialAccessorsToStorage(storage, TC.Context);
+      addTrivialAccessorsToStorage(storage, ctx);
       return;
     }
     // Fixed-layout global variables don't get accessors.
@@ -1502,12 +1503,13 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
       auto var = cast<VarDecl>(storage);
 
       if (var->isLet()) {
-        TC.diagnose(var->getLoc(),
-                   diag::protocol_property_must_be_computed_var)
+        ctx.Diags.diagnose(var->getLoc(),
+                           diag::protocol_property_must_be_computed_var)
           .fixItReplace(var->getParentPatternBinding()->getLoc(), "var")
           .fixItInsertAfter(var->getTypeLoc().getLoc(), " { get }");
       } else {
-        auto diag = TC.diagnose(var->getLoc(), diag::protocol_property_must_be_computed);
+        auto diag = ctx.Diags.diagnose(var->getLoc(),
+                                       diag::protocol_property_must_be_computed);
         auto braces = var->getBracesRange();
 
         if (braces.isValid())
@@ -1517,14 +1519,14 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
       }
     }
 
-    setProtocolStorageImpl(storage, TC.Context);
+    setProtocolStorageImpl(storage, ctx);
     return;
 
   // NSManaged properties on classes require special handling.
   } else if (dc->getSelfClassDecl()) {
     auto var = dyn_cast<VarDecl>(storage);
     if (var && var->getAttrs().hasAttribute<NSManagedAttr>()) {
-      convertNSManagedStoredVarToComputed(var, TC.Context);
+      convertNSManagedStoredVarToComputed(var, ctx);
       return;
     }
 
@@ -1539,13 +1541,13 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
   if (auto sourceFile = dc->getParentSourceFile())
     if (sourceFile->Kind == SourceFileKind::SIL) {
       if (storage->getGetter()) {
-        addExpectedOpaqueAccessorsToStorage(storage, TC.Context);
+        addExpectedOpaqueAccessorsToStorage(storage, ctx);
       }
       return;
     }
 
   // Everything else gets mandatory accessors.
-  addTrivialAccessorsToStorage(storage, TC.Context);
+  addTrivialAccessorsToStorage(storage, ctx);
 }
 
 static void synthesizeGetterBody(AccessorDecl *getter,

lib/Sema/CodeSynthesis.h

@@ -49,10 +49,14 @@ void makeFinal(ASTContext &ctx, ValueDecl *D);
 bool checkOverrides(ValueDecl *decl);
 
 // These are implemented in CodeSynthesis.cpp.
-void maybeAddAccessorsToStorage(TypeChecker &TC, AbstractStorageDecl *storage);
+void maybeAddAccessorsToStorage(AbstractStorageDecl *storage);
 
 void triggerAccessorSynthesis(TypeChecker &TC, AbstractStorageDecl *storage);
 
+/// Provide storage and accessor implementations for the given property,
+/// which must be lazy.
+void completeLazyVarImplementation(VarDecl *lazyVar);
+
 /// Describes the kind of implicit constructor that will be
 /// generated.
 enum class ImplicitConstructorKind {

lib/Sema/TypeCheckDecl.cpp

@@ -2018,7 +2018,7 @@ static void finalizeAbstractStorageDecl(TypeChecker &TC,
   TC.validateDecl(storage);
 
   // Add any mandatory accessors now.
-  maybeAddAccessorsToStorage(TC, storage);
+  maybeAddAccessorsToStorage(storage);
 
   for (auto accessor : storage->getAllAccessors()) {
     // Are there accessors we can safely ignore here, like maybe observers?
@@ -2124,7 +2124,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TC.validateDecl(VD);
 
     // Set up accessors.
-    maybeAddAccessorsToStorage(TC, VD);
+    maybeAddAccessorsToStorage(VD);
 
     // WARNING: Anything you put in this function will only be run when the
     // VarDecl is fully type-checked within its own file. It will NOT be run
@@ -4292,7 +4292,7 @@ void TypeChecker::requestMemberLayout(ValueDecl *member) {
     // because if they never get validated at all then conformance checkers
     // will complain about selector mismatches.
     if (storage->isObjC()) {
-      maybeAddAccessorsToStorage(*this, storage);
+      maybeAddAccessorsToStorage(storage);
       for (auto accessor : storage->getAllAccessors()) {
         requestMemberLayout(accessor);
       }
@@ -4345,7 +4345,7 @@ static void finalizeType(TypeChecker &TC, NominalTypeDecl *nominal) {
     if (prop->getAttrs().hasAttribute<LazyAttr>() && !prop->isStatic() &&
         (!prop->getGetter() || !prop->getGetter()->hasBody())) {
       finalizeAbstractStorageDecl(TC, prop);
-      TC.completeLazyVarImplementation(prop);
+      completeLazyVarImplementation(prop);
     }
   }
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -859,11 +859,8 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
       auto matchASD = cast<AbstractStorageDecl>(baseDecl);
       if (matchASD->isSetterAccessibleFrom(dc)) {
         // Match sure we've created the setter.
-        if (!matchASD->getSetter()) {
-          maybeAddAccessorsToStorage(
-                           *static_cast<TypeChecker *>(ctx.getLazyResolver()),
-                           matchASD);
-        }
+        if (!matchASD->getSetter())
+          maybeAddAccessorsToStorage(matchASD);
 
         auto matchSetterAccessScope = matchASD->getSetter()
           ->getFormalAccessScope(dc);
@@ -1759,13 +1756,9 @@ OverriddenDeclsRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
 
     // Check the various overridden storage declarations.
     SmallVector<OverrideMatch, 2> matches;
-    ASTContext &ctx = decl->getASTContext();
     for (auto overridden : overridingASD->getOverriddenDecls()) {
       auto baseASD = cast<AbstractStorageDecl>(overridden);
-      if (auto lazyResolver = ctx.getLazyResolver()) {
-        maybeAddAccessorsToStorage(*static_cast<TypeChecker *>(lazyResolver),
-                                   baseASD);
-      }
+      maybeAddAccessorsToStorage(baseASD);
 
       auto kind = accessor->getAccessorKind();
 

lib/Sema/TypeChecker.h

@@ -1266,10 +1266,6 @@ class TypeChecker final : public LazyResolver {
   void synthesizeWitnessAccessorsForStorage(AbstractStorageDecl *requirement,
                                             AbstractStorageDecl *storage);
 
-  /// Provide storage and accessor implementations for the given property,
-  /// which must be lazy.
-  void completeLazyVarImplementation(VarDecl *lazyVar);
-
   /// Pre-check the expression, validating any types that occur in the
   /// expression and folding sequence expressions.
   bool preCheckExpression(Expr *&expr, DeclContext *dc);