Add resilience boundary around non-exported decls

Author: tshortli

lib/Sema/TypeCheckAvailability.cpp

@@ -455,7 +455,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
     if (declarationIntroducesNewContext(D)) {
       return buildDeclarationRefinementContext(D);
     }
-    
+
     return nullptr;
   }
 
@@ -468,7 +468,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
     // probably to gin up a source range for the declaration when synthesizing
     // it.
     assert(D->getSourceRange().isValid());
-    
+
     // The potential versions in the declaration are constrained by both
     // the declared availability of the declaration and the potential versions
     // of its lexical context.
@@ -477,45 +477,69 @@ class TypeRefinementContextBuilder : private ASTWalker {
     AvailabilityContext DeclInfo = ExplicitDeclInfo;
     DeclInfo.intersectWith(getCurrentTRC()->getAvailabilityInfo());
 
-    TypeRefinementContext *NewTRC =
-        TypeRefinementContext::createForDecl(Context, D, getCurrentTRC(),
-                                             DeclInfo,
-                                             ExplicitDeclInfo,
-                                             refinementSourceRangeForDecl(D));
-    
+    // If the entire declaration is surrounded by a resilience boundary, it is
+    // also constrained by the deployment target.
+    if (signatureIsResilienceBoundary(D))
+      DeclInfo.intersectWith(AvailabilityContext::forDeploymentTarget(Context));
+
+    SourceRange Range = refinementSourceRangeForDecl(D);
+    TypeRefinementContext *NewTRC;
+    if (hasActiveAvailableAttribute(D, Context))
+      NewTRC = TypeRefinementContext::createForDecl(Context, D, getCurrentTRC(),
+                                                    DeclInfo, ExplicitDeclInfo,
+                                                    Range);
+    else
+      NewTRC =
+          TypeRefinementContext::createForResilienceBoundary(Context, D,
+                                                             getCurrentTRC(),
+                                                             DeclInfo, Range);
 
     // Possibly use this as an effective parent context later.
     recordEffectiveParentContext(D, NewTRC);
 
     return NewTRC;
   }
-  
+
   /// Returns true if the declaration should introduce a new refinement context.
   bool declarationIntroducesNewContext(Decl *D) {
     if (!isa<ValueDecl>(D) && !isa<ExtensionDecl>(D)) {
       return false;
     }
-    
+
+    // Ignore implicit declarations. This mainly skips over the functions in
+    // `DeferStmt`s.
+    if (D->isImplicit()) {
+      return false;
+    }
+
     // No need to introduce a context if the declaration does not have an
-    // availability attribute.
-    if (!hasActiveAvailableAttribute(D, Context)) {
+    // availability attribute and the signature is not a resilience boundary.
+    if (!hasActiveAvailableAttribute(D, Context) &&
+        !signatureIsResilienceBoundary(D)) {
       return false;
     }
-    
+
     // Only introduce for an AbstractStorageDecl if it is not local.
     // We introduce for the non-local case because these may
     // have getters and setters (and these may be synthesized, so they might
     // not even exist yet).
     if (auto *storageDecl = dyn_cast<AbstractStorageDecl>(D)) {
       if (storageDecl->getDeclContext()->isLocalContext()) {
-        // No need to
         return false;
       }
     }
-    
+
     return true;
   }
 
+  /// A declaration's signature is a resilience boundary if the entire
+  /// declaration--not just the body--is not ABI-public and it's in a context
+  /// where ABI-public declarations would be available below the minimum
+  /// deployment target.
+  bool signatureIsResilienceBoundary(Decl *D) {
+    return !isCurrentTRCContainedByDeploymentTarget() && !::isExported(D);
+  }
+
   /// Returns the source range which should be refined by declaration. This
   /// provides a convenient place to specify the refined range when it is
   /// different than the declaration's source range.

test/attr/attr_inlinable_available.swift

@@ -296,7 +296,7 @@ public func deployedUseAfterDeploymentTarget(
   _ = NoAvailable()
   _ = BeforeInliningTarget()
   _ = AtInliningTarget()
-  _ = BetweenTargets() // expected-error {{'BetweenTargets' is only available in}} {{18-25=10.14.5}} || {{31-35=12.3}} || {{42-46=12.3}} || {{56-59=5.3}}
+  _ = BetweenTargets() // expected-error {{'BetweenTargets' is only available in}} FIXME: should have {{18-25=10.14.5}} || {{31-35=12.3}} || {{42-46=12.3}} || {{56-59=5.3}}
   _ = AtDeploymentTarget() // expected-error {{'AtDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
   _ = AfterDeploymentTarget() // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
 
@@ -438,7 +438,7 @@ public func defaultArgsUseNoAvailable( // expected-note 3 {{add @available attri
   _: Any = AfterDeploymentTarget.self // expected-error {{'AfterDeploymentTarget' is only available in}}
 ) {}
 
-public struct PublicStruct { // expected-note 6 {{add @available attribute}}
+public struct PublicStruct { // expected-note 7 {{add @available attribute}}
   // Public declarations act like @inlinable.
   public var aPublic: NoAvailable
   public var bPublic: BeforeInliningTarget
@@ -451,18 +451,59 @@ public struct PublicStruct { // expected-note 6 {{add @available attribute}}
   var aInternal: NoAvailable
   var bInternal: BeforeInliningTarget
   var cInternal: AtInliningTarget
-  var dInternal: BetweenTargets // FIXME: expected-error {{'BetweenTargets' is only available in}}
-  var eInternal: AtDeploymentTarget // FIXME: expected-error {{'AtDeploymentTarget' is only available in}}
+  var dInternal: BetweenTargets
+  var eInternal: AtDeploymentTarget
+  var fInternal: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
+
+  @available(macOS 10.14.5, iOS 12.3, tvOS 12.3, watchOS 5.3, *)
+  public internal(set) var internalSetter: Void {
+    @inlinable get {
+      // Public inlinable getter acts like @inlinable
+      _ = NoAvailable()
+      _ = BeforeInliningTarget()
+      _ = AtInliningTarget()
+      _ = BetweenTargets()
+      _ = AtDeploymentTarget() // expected-error {{'AtDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
+      _ = AfterDeploymentTarget() // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
+
+    }
+    set {
+      // Private setter acts like non-inlinable
+      _ = NoAvailable()
+      _ = BeforeInliningTarget()
+      _ = AtInliningTarget()
+      _ = BetweenTargets()
+      _ = AtDeploymentTarget()
+      _ = AfterDeploymentTarget() // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
+    }
+  }
+}
+
+@frozen public struct FrozenPublicStruct { // expected-note 6 {{add @available attribute}}
+  // Public declarations act like @inlinable.
+  public var aPublic: NoAvailable
+  public var bPublic: BeforeInliningTarget
+  public var cPublic: AtInliningTarget
+  public var dPublic: BetweenTargets // expected-error {{'BetweenTargets' is only available in}}
+  public var ePublic: AtDeploymentTarget // expected-error {{'AtDeploymentTarget' is only available in}}
+  public var fPublic: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
+
+  // Internal declarations act like @inlinable in a frozen struct.
+  var aInternal: NoAvailable
+  var bInternal: BeforeInliningTarget
+  var cInternal: AtInliningTarget
+  var dInternal: BetweenTargets // expected-error {{'BetweenTargets' is only available in}}
+  var eInternal: AtDeploymentTarget // expected-error {{'AtDeploymentTarget' is only available in}}
   var fInternal: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
 }
 
-internal struct InternalStruct { // expected-note 3 {{add @available attribute}}
+internal struct InternalStruct { // expected-note {{add @available attribute}}
   // Internal declarations act like non-inlinable.
   var aInternal: NoAvailable
   var bInternal: BeforeInliningTarget
   var cInternal: AtInliningTarget
-  var dInternal: BetweenTargets // FIXME: expected-error {{'BetweenTargets' is only available in}}
-  var eInternal: AtDeploymentTarget // FIXME: expected-error {{'AtDeploymentTarget' is only available in}}
+  var dInternal: BetweenTargets
+  var eInternal: AtDeploymentTarget
   var fInternal: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
 }