Remove AbstractStorageDecl::isFormallyResilient.

Update DeclContext::bypassResilienceInPackage.

Author: elsh

include/swift/AST/Decl.h

@@ -5842,13 +5842,6 @@ class AbstractStorageDecl : public ValueDecl {
                                    ModuleDecl *module,
                                    ResilienceExpansion expansion) const;
 
-  /// Should this declaration behave as if it must be accessed
-  /// resiliently, even when we're building a non-resilient module?
-  ///
-  /// This is used for diagnostics, because we do not want a behavior
-  /// change between builds with resilience enabled and disabled.
-  bool isFormallyResilient() const;
-
   /// Do we need to use resilient access patterns outside of this
   /// property's resilience domain?
   bool isResilient() const;

include/swift/AST/DeclContext.h

@@ -535,7 +535,7 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   /// (possibly also public types later) if opted-in, client and defining module
   /// are in the same package, and the defining module is a binary module.
   LLVM_READONLY
-  bool allowBypassResilienceInPackage(bool isForPackageDecl) const;
+  bool bypassResilienceInPackage(bool isForPackageDecl) const;
 
   /// Returns the module context that contains this context.
   LLVM_READONLY

lib/AST/Decl.cpp

@@ -2952,15 +2952,13 @@ bool Decl::isOutermostPrivateOrFilePrivateScope() const {
          !isInPrivateOrLocalContext(this);
 }
 
-bool AbstractStorageDecl::isFormallyResilient() const {
+bool AbstractStorageDecl::isResilient() const {
   // Check for an explicit @_fixed_layout attribute.
   if (getAttrs().hasAttribute<FixedLayoutAttr>())
     return false;
 
-  // If we're an instance property of a nominal type, query the type.
-  auto *dc = getDeclContext();
   if (!isStatic())
-    if (auto *nominalDecl = dc->getSelfNominalTypeDecl())
+    if (auto *nominalDecl = getDeclContext()->getSelfNominalTypeDecl())
       return nominalDecl->isResilient();
 
   // Non-public global and static variables always have a
@@ -2969,19 +2967,14 @@ bool AbstractStorageDecl::isFormallyResilient() const {
                             /*treatUsableFromInlineAsPublic=*/true).isPublicOrPackage())
     return false;
 
-  return true;
-}
-
-bool AbstractStorageDecl::isResilient() const {
-  if (!isFormallyResilient())
-    return false;
   if (!getModuleContext()->isResilient())
     return false;
+
   // Allows bypassing resilience checks for package decls
   // at use site within a package if opted in, whether the
   // loaded module was built resiliently or not.
-  return !getDeclContext()->allowBypassResilienceInPackage(getFormalAccessScope(/*useDC=*/nullptr,
-                                                                                /*treatUsableFromInlineAsPublic=*/true).isPackage());
+  return !getDeclContext()->bypassResilienceInPackage(getFormalAccessScope(/*useDC=*/nullptr,
+                                                                           /*treatUsableFromInlineAsPublic=*/true).isPackage());
 }
 
 bool AbstractStorageDecl::isResilient(ModuleDecl *M,
@@ -5057,8 +5050,8 @@ bool NominalTypeDecl::isResilient() const {
   // Allows bypassing resilience checks for package decls
   // at use site within a package if opted in, whether the
   // loaded module was built resiliently or not.
-  return !getDeclContext()->allowBypassResilienceInPackage(getFormalAccessScope(/*useDC=*/nullptr,
-                                                                                /*treatUsableFromInlineAsPublic=*/true).isPackage());
+  return !getDeclContext()->bypassResilienceInPackage(getFormalAccessScope(/*useDC=*/nullptr,
+                                                                           /*treatUsableFromInlineAsPublic=*/true).isPackage());
 }
 
 DestructorDecl *NominalTypeDecl::getValueTypeDestructor() {
@@ -6382,7 +6375,7 @@ bool EnumDecl::isFormallyExhaustive(const DeclContext *useDC) const {
   // package enum is optimized with bypassing resilience checks.
   if (!accessScope.isPublicOrPackage())
     return true;
-  if (useDC && useDC->allowBypassResilienceInPackage(accessScope.isPackage()))
+  if (useDC && useDC->bypassResilienceInPackage(accessScope.isPackage()))
     return true;
 
   // All other checks are use-site specific; with no further information, the

lib/AST/DeclContext.cpp

@@ -300,23 +300,12 @@ PackageUnit *DeclContext::getPackageContext(bool lookupIfNotCurrent) const {
   return nullptr;
 }
 
-bool DeclContext::allowBypassResilienceInPackage(bool isForPackageDecl) const {
-  // Bypassing resilience checks only applies to package types.
-  if (!isForPackageDecl)
-    return false;
-
-  auto shouldAllow = true;
-  // Check if the enclosing type is non-resilient.
-  if (auto enclosingNominal = dyn_cast<NominalTypeDecl>(this)) {
-    shouldAllow = !enclosingNominal->isResilient();
-  } else if (auto enclosingExt = dyn_cast<ExtensionDecl>(this)) {
-    if (auto extNominal = enclosingExt->getExtendedNominal())
-      shouldAllow = !extNominal->isResilient();
-  }
-
-  // Check if opted-in for bypassing resilience checks, client and defining
-  // module are in the same package, and defining module is a binary module.
-  return shouldAllow &&
+bool DeclContext::bypassResilienceInPackage(bool isForPackageDecl) const {
+  // Bypassing resilience checks only applies to package types (and possibly
+  // public types in a package in the future). Allowed only if opted-in for
+  // bypassing checks, client and defining module are in the same package,
+  // and defining module is a binary module.
+  return isForPackageDecl &&
          getASTContext().LangOpts.EnableBypassResilienceInPackage &&
          getParentModule()->inPackage(getASTContext().LangOpts.PackageName) &&
          !getParentModule()->isBuiltFromInterface();

lib/SILGen/SILGen.cpp

@@ -1889,7 +1889,10 @@ static bool canStorageUseTrivialDescriptor(SILGenModule &SGM,
     if (SGM.canStorageUseStoredKeyPathComponent(decl, expansion)) {
       // External modules can't directly access storage, unless this is a
       // property in a fixed-layout type.
-      return !decl->isFormallyResilient();
+      // Assert here as key path component cannot refer to a static var.
+      assert(!decl->isStatic());
+      // By this point, decl is a fixed layout or its enclosing type is non-resilient.
+      return true;
     }
 
     // If the type is computed and doesn't have a setter that's hidden from