Ensure that @safe(unchecked) only applies to bodies (not declarations)

Author: DougGregor

include/swift/AST/AvailabilityContext.h

@@ -106,6 +106,9 @@ class AvailabilityContext {
   constrainWithDeclAndPlatformRange(const Decl *decl,
                                     const AvailabilityRange &platformRange);
 
+  /// Constrain to allow unsafe code.
+  void constrainWithAllowsUnsafe(ASTContext &ctx);
+
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const AvailabilityContext other) const;
 

lib/AST/AvailabilityContext.cpp

@@ -194,6 +194,15 @@ void AvailabilityContext::constrainWithDecl(const Decl *decl) {
   constrainWithDeclAndPlatformRange(decl, AvailabilityRange::alwaysAvailable());
 }
 
+void AvailabilityContext::constrainWithAllowsUnsafe(ASTContext &ctx) {
+  if (allowsUnsafe())
+    return;
+
+  PlatformInfo platformInfo{Info->Platform};
+  platformInfo.AllowsUnsafe = true;
+  Info = Storage::get(platformInfo, ctx);
+}
+
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
   PlatformInfo platformAvailability{Info->Platform};

lib/AST/Decl.cpp

@@ -1080,7 +1080,7 @@ bool Decl::isUnsafe() const {
 }
 
 bool Decl::allowsUnsafe() const {
-  return getAttrs().hasAttribute<SafeAttr>() || isUnsafe();
+  return isUnsafe();
 }
 
 Type AbstractFunctionDecl::getThrownInterfaceType() const {

lib/Sema/TypeCheckAvailability.cpp

@@ -869,100 +869,140 @@ class AvailabilityScopeBuilder : private ASTWalker {
     return Range;
   }
 
-  // Creates an implicit decl scope specifying the deployment target for
-  // `range` in decl `D`.
-  AvailabilityScope *
-  createImplicitDeclContextForDeploymentTarget(Decl *D, SourceRange range) {
-    const AvailabilityContext Availability =
-        constrainCurrentAvailabilityWithPlatformRange(
-            AvailabilityRange::forDeploymentTarget(Context));
-    return AvailabilityScope::createForDeclImplicit(
-        Context, D, getCurrentScope(), Availability, range);
-  }
-
-  void buildContextsForBodyOfDecl(Decl *D) {
-    // Are we already constrained by the deployment target? If not, adding
-    // new contexts won't change availability.
-    if (isCurrentScopeContainedByDeploymentTarget())
-      return;
-
+  /// Enumerate the AST nodes and their corresponding source ranges for
+  /// the body (or bodies) of the given declaration.
+  void enumerateBodyRanges(
+     Decl *decl,
+     llvm::function_ref<void(Decl *decl, ASTNode body, SourceRange)> acceptBody
+  ) {
     // Top level code always uses the deployment target.
-    if (auto tlcd = dyn_cast<TopLevelCodeDecl>(D)) {
+    if (auto tlcd = dyn_cast<TopLevelCodeDecl>(decl)) {
       if (auto bodyStmt = tlcd->getBody()) {
-        pushDeclBodyContext(
-            tlcd, {{bodyStmt, createImplicitDeclContextForDeploymentTarget(
-                                  tlcd, refinementSourceRangeForDecl(tlcd))}});
+        acceptBody(tlcd, bodyStmt, refinementSourceRangeForDecl(tlcd));
       }
       return;
     }
 
-    // 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->getResilienceExpansion() != ResilienceExpansion::Minimal) {
+    // For functions, provide the body source range.
+    if (auto afd = dyn_cast<AbstractFunctionDecl>(decl)) {
+      if (!afd->isImplicit()) {
         if (auto body = afd->getBody(/*canSynthesize*/ false)) {
-          pushDeclBodyContext(
-              afd, {{body, createImplicitDeclContextForDeploymentTarget(
-                               afd, afd->getBodySourceRange())}});
+          acceptBody(afd, body, afd->getBodySourceRange());
         }
       }
       return;
     }
 
-    // Pattern binding declarations can have children corresponding to property
-    // wrappers and the initial values provided in each pattern binding entry
-    if (auto *pbd = dyn_cast<PatternBindingDecl>(D)) {
-      llvm::SmallVector<std::pair<ASTNode, AvailabilityScope *>, 4>
-          nodesAndScopes;
-
+    // Pattern binding declarations have initial values that are their
+    // bodies.
+    if (auto *pbd = dyn_cast<PatternBindingDecl>(decl)) {
       for (unsigned index : range(pbd->getNumPatternEntries())) {
         auto var = pbd->getAnchoringVarDecl(index);
         if (!var)
           continue;
 
-        // 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 (!var->hasInitialValue() || var->isInitExposedToClients())
-          continue;
-
         auto *initExpr = pbd->getInit(index);
         if (initExpr && !initExpr->isImplicit()) {
           assert(initExpr->getSourceRange().isValid());
 
           // Create a scope for the init written in the source.
-          nodesAndScopes.push_back(
-              {initExpr, createImplicitDeclContextForDeploymentTarget(
-                             var, initExpr->getSourceRange())});
+          acceptBody(var, initExpr, initExpr->getSourceRange());
         }
       }
+      return;
+    }
+  }
+
+  // Creates an implicit decl scope specifying the deployment target for
+  // `range` in decl `D`.
+  AvailabilityScope *
+  createImplicitDeclContextForDeploymentTarget(Decl *D, SourceRange range) {
+    const AvailabilityContext Availability =
+        constrainCurrentAvailabilityWithPlatformRange(
+            AvailabilityRange::forDeploymentTarget(Context));
+    return AvailabilityScope::createForDeclImplicit(
+        Context, D, getCurrentScope(), Availability, range);
+  }
+
+  /// Determine whether the body of the given declaration has
+  /// deployment-target availability.
+  static bool bodyIsDeploymentTarget(Decl *decl) {
+    if (auto afd = dyn_cast<AbstractFunctionDecl>(decl)) {
+      return afd->getResilienceExpansion() != ResilienceExpansion::Minimal;
+    }
+
+    if (auto var = dyn_cast<VarDecl>(decl)) {
+      // 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.
+      return var->hasInitialValue() && !var->isInitExposedToClients();
+    }
+
+    return true;
+  }
+
+  void buildContextsForBodyOfDecl(Decl *D) {
+    // Are we already constrained by the deployment target and the declaration
+    // doesn't explicitly allow unsafe constructs in its definition, adding
+    // new contexts won't change availability.
+    bool allowsUnsafe = D->getAttrs().hasAttribute<SafeAttr>();
+    if (isCurrentScopeContainedByDeploymentTarget() && !allowsUnsafe)
+      return;
+
+    // Enumerate all of the body scopes to apply availability.
+    llvm::SmallVector<std::pair<ASTNode, AvailabilityScope *>, 4>
+        nodesAndScopes;
+    enumerateBodyRanges(D, [&](Decl *decl, ASTNode body, SourceRange range) {
+      auto availability = getCurrentScope()->getAvailabilityContext();
+
+      // Apply deployment-target availability if appropriate for this body.
+      if (!isCurrentScopeContainedByDeploymentTarget() &&
+          bodyIsDeploymentTarget(decl)) {
+        availability.constrainWithPlatformRange(
+             AvailabilityRange::forDeploymentTarget(Context), Context);
+      }
+
+      // Allow unsafe if appropriate for this body.
+      if (allowsUnsafe) {
+        availability.constrainWithAllowsUnsafe(Context);
+      }
 
-      if (nodesAndScopes.size() > 0)
-        pushDeclBodyContext(pbd, nodesAndScopes);
-
-      // 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 and use its source range to create a
-      // scope for the initializer expression.
-      //
-      // FIXME: Since we don't have an expression here, we can't build out its
-      // scope. If the Expr that will eventually be created contains a closure
-      // expression, then it might have AST nodes that need to be refined. For
-      // example, property wrapper initializers that takes block arguments
-      // are not handled correctly because of this (rdar://77841331).
-      if (auto firstVar = pbd->getAnchoringVarDecl(0)) {
-        if (firstVar->hasInitialValue() &&
-            !firstVar->isInitExposedToClients()) {
-          for (auto *wrapper : firstVar->getAttachedPropertyWrappers()) {
-            createImplicitDeclContextForDeploymentTarget(firstVar,
-                                                         wrapper->getRange());
+      nodesAndScopes.push_back({
+          body,
+          AvailabilityScope::createForDeclImplicit(
+              Context, decl, getCurrentScope(), availability, range)
+      });
+    });
+
+    if (nodesAndScopes.size() > 0)
+      pushDeclBodyContext(D, nodesAndScopes);
+
+    if (!isCurrentScopeContainedByDeploymentTarget()) {
+      // Pattern binding declarations can have children corresponding to property
+      // wrappers, which we handle separately.
+      if (auto *pbd = dyn_cast<PatternBindingDecl>(D)) {
+        // 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 and use its source range to create a
+        // scope for the initializer expression.
+        //
+        // FIXME: Since we don't have an expression here, we can't build out its
+        // scope. If the Expr that will eventually be created contains a closure
+        // expression, then it might have AST nodes that need to be refined. For
+        // example, property wrapper initializers that takes block arguments
+        // are not handled correctly because of this (rdar://77841331).
+        if (auto firstVar = pbd->getAnchoringVarDecl(0)) {
+          if (firstVar->hasInitialValue() &&
+              !firstVar->isInitExposedToClients()) {
+            for (auto *wrapper : firstVar->getAttachedPropertyWrappers()) {
+              createImplicitDeclContextForDeploymentTarget(firstVar,
+                                                           wrapper->getRange());
+            }
           }
         }
       }
-      return;
     }
   }