WIP rdar://92713589

Author: tshortli

lib/Sema/TypeCheckAvailability.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/Initializer.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/Pattern.h"
+#include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeDeclFinder.h"
@@ -320,21 +321,6 @@ static bool hasActiveAvailableAttribute(Decl *D,
   return getActiveAvailableAttribute(D, AC);
 }
 
-static bool shouldConstrainBodyToDeploymentTarget(Decl *D) {
-  // The declaration contains code...
-  if (auto afd = dyn_cast<AbstractFunctionDecl>(D)) {
-    // And it has a location so we can check it...
-    if (!afd->isImplicit() && afd->getBodySourceRange().isValid()) {
-      // And the code is within our resilience domain, so it should be
-      // compiled with the minimum deployment target, not the minimum inlining
-      // target.
-      return afd->getResilienceExpansion() != ResilienceExpansion::Minimal;
-    }
-  }
-
-  return false;
-}
-
 static bool computeContainedByDeploymentTarget(TypeRefinementContext *TRC,
                                                ASTContext &ctx) {
   return TRC->getAvailabilityInfo()
@@ -418,6 +404,10 @@ class TypeRefinementContextBuilder : private ASTWalker {
     ContextStack.push_back(Info);
   }
 
+  const char *stackTraceAction() const {
+    return "building type refinement context";
+  }
+
 public:
   TypeRefinementContextBuilder(TypeRefinementContext *TRC, ASTContext &Context)
       : Context(Context) {
@@ -426,20 +416,23 @@ class TypeRefinementContextBuilder : private ASTWalker {
   }
 
   void build(Decl *D) {
+    PrettyStackTraceDecl trace(stackTraceAction(), D);
     unsigned StackHeight = ContextStack.size();
     D->walk(*this);
     assert(ContextStack.size() == StackHeight);
     (void)StackHeight;
   }
 
   void build(Stmt *S) {
+    PrettyStackTraceStmt trace(Context, stackTraceAction(), S);
     unsigned StackHeight = ContextStack.size();
     S->walk(*this);
     assert(ContextStack.size() == StackHeight);
     (void)StackHeight;
   }
 
   void build(Expr *E) {
+    PrettyStackTraceExpr trace(Context, stackTraceAction(), E);
     unsigned StackHeight = ContextStack.size();
     E->walk(*this);
     assert(ContextStack.size() == StackHeight);
@@ -448,6 +441,8 @@ class TypeRefinementContextBuilder : private ASTWalker {
 
 private:
   bool walkToDeclPre(Decl *D) override {
+    PrettyStackTraceDecl trace(stackTraceAction(), D);
+
     // Adds in a parent TRC for decls which are syntactically nested but are not
     // represented that way in the AST. (Particularly, AbstractStorageDecl
     // parents for AccessorDecl children.)
@@ -460,17 +455,12 @@ class TypeRefinementContextBuilder : private ASTWalker {
       pushContext(DeclTRC, D);
     }
 
-    // Adds in a TRC that covers only the body of the declaration.
-    if (auto BodyTRC = getNewContextForBodyOfDecl(D)) {
-      pushContext(BodyTRC, D);
-    }
-
+    // Create TRCs that cover only the body of the declaration.
+    buildContextsForBodyOfDecl(D);
     return true;
   }
 
   bool walkToDeclPost(Decl *D) override {
-    // As seen above, we could have up to three TRCs in the stack for a single
-    // declaration.
     while (ContextStack.back().ScopeNode.getAsDecl() == D) {
       ContextStack.pop_back();
     }
@@ -515,7 +505,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
     return nullptr;
   }
 
-  /// Builds the type refinement hierarchy for the body of the function.
+  /// Builds the type refinement hierarchy for the signature of the declaration.
   TypeRefinementContext *buildDeclarationRefinementContext(Decl *D) {
     // We require a valid range in order to be able to query for the TRC
     // corresponding to a given SourceLoc.
@@ -611,15 +601,19 @@ class TypeRefinementContextBuilder : private ASTWalker {
     if (auto *storageDecl = dyn_cast<AbstractStorageDecl>(D)) {
       // Use the declaration's availability for the context when checking
       // the bodies of its accessors.
+      SourceRange Range = storageDecl->getSourceRange();
 
-      Decl *locDecl = D;
       // For a variable declaration (without accessors) we use the range of the
       // containing pattern binding declaration to make sure that we include
-      // any type annotation in the type refinement context range.
-      if (auto varDecl = dyn_cast<VarDecl>(storageDecl)) {
-        auto *PBD = varDecl->getParentPatternBinding();
-        if (PBD)
-          locDecl = PBD;
+      // any type annotation in the type refinement context range. We also
+      // need to include any attached property wrappers.
+      if (auto *varDecl = dyn_cast<VarDecl>(storageDecl)) {
+        if (auto *PBD = varDecl->getParentPatternBinding())
+          Range = PBD->getSourceRange();
+
+        for (auto *propertyWrapper : varDecl->getAttachedPropertyWrappers()) {
+          Range.widen(propertyWrapper->getRange());
+        }
       }
 
       // HACK: For synthesized trivial accessors we may have not a valid
@@ -628,58 +622,91 @@ class TypeRefinementContextBuilder : private ASTWalker {
       // to update AbstractStorageDecl::addTrivialAccessors() to take brace
       // locations and have callers of that method provide appropriate source
       // locations.
-      SourceLoc BracesEnd = storageDecl->getBracesRange().End;
-      if (storageDecl->hasParsedAccessors() && BracesEnd.isValid()) {
-        return SourceRange(locDecl->getStartLoc(),
-                           BracesEnd);
+      SourceRange BracesRange = storageDecl->getBracesRange();
+      if (storageDecl->hasParsedAccessors() && BracesRange.isValid()) {
+        Range.widen(BracesRange);
       }
 
-      return locDecl->getSourceRange();
+      return Range;
     }
 
     return D->getSourceRange();
   }
 
-  TypeRefinementContext *getNewContextForBodyOfDecl(Decl *D) {
-    if (bodyIntroducesNewContext(D))
-      return buildBodyRefinementContext(D);
+  TypeRefinementContext *createAPIBoundaryContext(Decl *D, SourceRange range) {
+    AvailabilityContext DeploymentTargetInfo =
+        AvailabilityContext::forDeploymentTarget(Context);
+    DeploymentTargetInfo.intersectWith(getCurrentTRC()->getAvailabilityInfo());
 
-    return nullptr;
+    return TypeRefinementContext::createForAPIBoundary(
+        Context, D, getCurrentTRC(), DeploymentTargetInfo, range);
   }
 
-  bool bodyIntroducesNewContext(Decl *D) {
-    // Are we already constrained by the deployment target? If not, adding a
-    // new context wouldn't change availability.
+  void buildContextsForBodyOfDecl(Decl *D) {
+    // Are we already constrained by the deployment target? If not, adding
+    // new contexts won't change availability.
     if (isCurrentTRCContainedByDeploymentTarget())
-      return false;
-
-    // If we're in a function, check if it ought to use the deployment target.
-    if (auto afd = dyn_cast<AbstractFunctionDecl>(D))
-      return shouldConstrainBodyToDeploymentTarget(afd);
-
-    // The only other case we care about is top-level code.
-    return isa<TopLevelCodeDecl>(D);
-  }
+      return;
 
-  TypeRefinementContext *buildBodyRefinementContext(Decl *D) {
-    SourceRange range;
+    // Top level code always uses the deployment target.
     if (auto tlcd = dyn_cast<TopLevelCodeDecl>(D)) {
-      range = tlcd->getSourceRange();
-    } else if (auto afd = dyn_cast<AbstractFunctionDecl>(D)) {
-      range = afd->getBodySourceRange();
-    } else {
-      llvm_unreachable("unknown decl");
+      pushContext(createAPIBoundaryContext(tlcd, tlcd->getSourceRange()), D);
+      return;
     }
 
-    AvailabilityContext DeploymentTargetInfo =
-        AvailabilityContext::forDeploymentTarget(Context);
-    DeploymentTargetInfo.intersectWith(getCurrentTRC()->getAvailabilityInfo());
+    // Function bodies use the deployment target if they are within the module's
+    // resilience domain.
+    if (auto afd = dyn_cast<AbstractFunctionDecl>(D)) {
+      if (!afd->isImplicit() && afd->getBodySourceRange().isValid() &&
+          afd->getResilienceExpansion() != ResilienceExpansion::Minimal) {
+        pushContext(createAPIBoundaryContext(afd, afd->getBodySourceRange()),
+                    D);
+      }
+      return;
+    }
 
-    return TypeRefinementContext::createForAPIBoundary(
-        Context, D, getCurrentTRC(), DeploymentTargetInfo, range);
+    // Var decls may have associated pattern binding decls or property wrappers
+    // with init expressions. Those expressions need to be constrained to the
+    // deployment target unless they are exposed to clients.
+    if (auto vd = dyn_cast<VarDecl>(D)) {
+      if (!vd->hasInitialValue() || vd->isInitExposedToClients())
+        return;
+
+      if (auto *pbd = vd->getParentPatternBinding()) {
+        int idx = pbd->getPatternEntryIndexForVarDecl(vd);
+        auto *initExpr = pbd->getInit(idx);
+        if (initExpr && !initExpr->isImplicit()) {
+          assert(initExpr->getSourceRange().isValid());
+
+          // Create a TRC for the init written in the source. The ASTWalker
+          // won't visit these expressions so instead of pushing these onto the
+          // stack we build them directly.
+          auto *initTRC =
+              createAPIBoundaryContext(vd, initExpr->getSourceRange());
+          TypeRefinementContextBuilder(initTRC, Context).build(initExpr);
+        }
+
+        // Ideally any init expression would be returned by `getInit()` above.
+        // However, for property wrappers it doesn't get populated until
+        // typechecking completes (which is too late). Instead, we find the
+        // the property wrapper attribute use its source range to create a TRC
+        // for the initializer expression.
+        // FIXME: Since we don't have an expression here, we can't build out its
+        // TRC. Currently that doesn't matter because expression contents don't
+        // ever contribute to the TRC, but it could become relevant if we ever
+        // get control flow expressions.
+        for (auto *wrapper : vd->getAttachedPropertyWrappers()) {
+          createAPIBoundaryContext(vd, wrapper->getRange());
+        }
+      }
+
+      return;
+    }
   }
 
   std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
+    PrettyStackTraceStmt trace(Context, stackTraceAction(), S);
+
     if (auto *IS = dyn_cast<IfStmt>(S)) {
       buildIfStmtRefinementContext(IS);
       return std::make_pair(false, S);