Support bypassing resilience checks for package decls at use site in a package.

By default package decls are treated as resilient, similar to public (non-frozen).
This PR adds support to allow direct access to package decls at use site if opted-in.
Requires the loaded module to be a binary module in the same package.

Resolves rdar://121626315

Author: elsh

include/swift/AST/Decl.h

@@ -2920,10 +2920,6 @@ class ValueDecl : public Decl {
   /// if the base declaration is \c open, the override might have to be too.
   bool hasOpenAccess(const DeclContext *useDC) const;
 
-  /// Returns whether this declaration should be treated as having the \c
-  /// package access level.
-  bool hasPackageAccess() const;
-
   /// FIXME: This is deprecated.
   bool isRecursiveValidation() const;
 

include/swift/AST/DeclContext.h

@@ -530,6 +530,13 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   LLVM_READONLY
   PackageUnit *getPackageContext(bool lookupIfNotCurrent = false) const;
 
+  /// True if resilience checks can be bypassed within a package.
+  /// \p isForPackageDecl Bypassing only applies to package types
+  /// (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;
+
   /// Returns the module context that contains this context.
   LLVM_READONLY
   ModuleDecl *getParentModule() const;

include/swift/AST/Module.h

@@ -480,6 +480,10 @@ class ModuleDecl
     return Identifier();
   }
 
+  bool inPackage(std::string packageName) {
+    return !getPackageName().empty() && getPackageName().str() == packageName;
+  }
+
   /// Get the package associated with this module
   PackageUnit *getPackage() const { return Package; }
 

include/swift/Basic/LangOptions.h

@@ -186,6 +186,9 @@ namespace swift {
     /// Disable API availability checking.
     bool DisableAvailabilityChecking = false;
 
+    /// Enable optimization to bypass resilience checks in a package
+    bool EnableBypassResilienceInPackage = false;
+
     /// Optimization mode for unavailable declarations.
     llvm::Optional<UnavailableDeclOptimization> UnavailableDeclOptimizationMode;
 

include/swift/Option/Options.td

@@ -516,6 +516,10 @@ def unavailable_decl_optimization_EQ : Joined<["-"], "unavailable-decl-optimizat
            "value may be 'none' (no optimization) or 'complete' (code is not "
            "generated at all unavailable declarations)">;
 
+def package_bypass_resilience_optimization : Flag<["-"], "package-bypass-resilience-optimization">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable optimization to bypass resilience within a package">;
+
 def library_level : Separate<["-"], "library-level">,
   MetaVarName<"<level>">,
   Flags<[HelpHidden, FrontendOption, ModuleInterfaceOption]>,

lib/AST/Decl.cpp

@@ -2975,8 +2975,13 @@ bool AbstractStorageDecl::isFormallyResilient() const {
 bool AbstractStorageDecl::isResilient() const {
   if (!isFormallyResilient())
     return false;
-
-  return getModuleContext()->isResilient();
+  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());
 }
 
 bool AbstractStorageDecl::isResilient(ModuleDecl *M,
@@ -4207,13 +4212,6 @@ bool ValueDecl::hasOpenAccess(const DeclContext *useDC) const {
   return access == AccessLevel::Open;
 }
 
-bool ValueDecl::hasPackageAccess() const {
-  AccessLevel access =
-      getAdjustedFormalAccess(this, /*useDC*/ nullptr,
-                              /*treatUsableFromInlineAsPublic*/ false);
-  return access == AccessLevel::Package;
-}
-
 /// Given the formal access level for using \p VD, compute the scope where
 /// \p VD may be accessed, taking \@usableFromInline, \@testable imports,
 /// \@_spi imports, and enclosing access levels into account.
@@ -5054,8 +5052,13 @@ bool NominalTypeDecl::isFormallyResilient() const {
 bool NominalTypeDecl::isResilient() const {
   if (!isFormallyResilient())
     return false;
-
-  return getModuleContext()->isResilient();
+  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());
 }
 
 DestructorDecl *NominalTypeDecl::getValueTypeDestructor() {
@@ -6375,7 +6378,11 @@ bool EnumDecl::isFormallyExhaustive(const DeclContext *useDC) const {
   // Non-public, non-versioned enums are always exhaustive.
   AccessScope accessScope = getFormalAccessScope(/*useDC*/nullptr,
                                                  /*respectVersioned*/true);
-  if (!accessScope.isPublic())
+  // Both public and package enums should behave the same unless
+  // package enum is optimized with bypassing resilience checks.
+  if (!accessScope.isPublicOrPackage())
+    return true;
+  if (useDC && useDC->allowBypassResilienceInPackage(accessScope.isPackage()))
     return true;
 
   // All other checks are use-site specific; with no further information, the

lib/AST/DeclContext.cpp

@@ -300,6 +300,28 @@ 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 &&
+         getASTContext().LangOpts.EnableBypassResilienceInPackage &&
+         getParentModule()->inPackage(getASTContext().LangOpts.PackageName) &&
+         !getParentModule()->isBuiltFromInterface();
+}
+
 ModuleDecl *DeclContext::getParentModule() const {
   // If the current context is PackageUnit, return the module
   // decl context pointing to the current context. This check

lib/AST/ProtocolConformance.cpp

@@ -349,7 +349,6 @@ bool NormalProtocolConformance::isResilient() const {
   // individual witnesses.
   if (!getDeclContext()->getSelfNominalTypeDecl()->isResilient())
     return false;
-
   return getDeclContext()->getParentModule()->isResilient();
 }
 

lib/Driver/ToolChains.cpp

@@ -299,6 +299,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_Rpass_missed_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_suppress_warnings);
   inputArgs.AddLastArg(arguments, options::OPT_suppress_remarks);
+  inputArgs.AddLastArg(arguments, options::OPT_package_bypass_resilience_optimization);
   inputArgs.AddLastArg(arguments, options::OPT_profile_generate);
   inputArgs.AddLastArg(arguments, options::OPT_profile_use);
   inputArgs.AddLastArg(arguments, options::OPT_profile_coverage_mapping);
@@ -551,7 +552,7 @@ ToolChain::constructInvocation(const CompileJobAction &job,
   if (context.Args.hasArg(options::OPT_CrossModuleOptimization)) {
     Arguments.push_back("-cross-module-optimization");
   }
-                                 
+
   if (context.Args.hasArg(options::OPT_ExperimentalPerformanceAnnotations)) {
     Arguments.push_back("-experimental-performance-annotations");
   }

lib/Frontend/CompilerInvocation.cpp

@@ -671,6 +671,8 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnablePackageInterfaceLoad = Args.hasArg(OPT_experimental_package_interface_load) ||
                                     ::getenv("SWIFT_ENABLE_PACKAGE_INTERFACE_LOAD");
 
+  Opts.EnableBypassResilienceInPackage = Args.hasArg(OPT_package_bypass_resilience_optimization);
+
   Opts.DisableAvailabilityChecking |=
       Args.hasArg(OPT_disable_availability_checking);
   if (Args.hasArg(OPT_check_api_availability_only))