Currently when checking if resilience check can be bypassed within a package,

we only check if the loaded module is built from a package interface. This is
not enough as a binary module could just contain exportable decls if built with
experimental-skip-non-exportable-decls, essentially resulting in content equivalent
to interface content. This might be made a default behavior so this PR requires
a module to opt in to allow non-resilient access by a participating client in the
same package.

Since it affects module format, SWIFTMODULE_VERSION_MINOR is updated.

rdar://123651270

Author: elsh

include/swift/AST/Decl.h

@@ -694,7 +694,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     HasAnyUnavailableDuringLoweringValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -750,7 +750,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     ObjCNameLookupCachePopulated : 1,
 
     /// Whether this module has been built with C++ interoperability enabled.
-    HasCxxInteroperability : 1
+    HasCxxInteroperability : 1,
+
+    /// Whether this module has been built with -experimental-allow-non-resilient-access.
+    AllowNonResilientAccess : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,
@@ -2931,9 +2934,9 @@ class ValueDecl : public Decl {
   /// if the base declaration is \c open, the override might have to be too.
   bool hasOpenAccess(const DeclContext *useDC) const;
 
-  /// True if opted in for bypassing resilience within a package. Allowed only on
-  /// access from the \p accessingModule to a package decl in the defining
-  /// binary (not interface) module within the same package.
+  /// True if opted in to bypass a resilience check at the use site in the
+  /// \p accessingModule that references decls defined in a module
+  /// that allows non-resilient access within the same package.
   bool bypassResilienceInPackage(ModuleDecl *accessingModule) const;
 
   /// FIXME: This is deprecated.

include/swift/AST/DiagnosticsFrontend.def

@@ -168,6 +168,8 @@ WARNING(emit_reference_dependencies_without_primary_file,none,
 
 WARNING(ignoring_option_requires_option,none,
         "ignoring %0 (requires %1)", (StringRef, StringRef))
+WARNING(warn_ignore_option_overriden_by,none,
+        "ignoring %0 (overriden by %1)", (StringRef, StringRef))
 
 WARNING(warn_implicit_concurrency_import_failed,none,
         "unable to perform implicit import of \"_Concurrency\" module: no such module found", ())

include/swift/AST/Module.h

@@ -711,6 +711,16 @@ class ModuleDecl
     Bits.ModuleDecl.IsBuiltFromInterface = flag;
   }
 
+  /// Returns true if -experimental-allow-non-resilient-access was passed
+  /// and the module is built from source.
+  bool allowNonResilientAccess() const {
+    return Bits.ModuleDecl.AllowNonResilientAccess &&
+          !Bits.ModuleDecl.IsBuiltFromInterface;
+  }
+  void setAllowNonResilientAccess(bool flag = true) {
+    Bits.ModuleDecl.AllowNonResilientAccess = flag;
+  }
+
   /// Returns true if this module is a non-Swift module that was imported into
   /// Swift.
   ///

include/swift/Frontend/FrontendOptions.h

@@ -311,6 +311,10 @@ class FrontendOptions {
   /// Should we skip decls that cannot be referenced externally?
   bool SkipNonExportableDecls = false;
 
+  /// True if -experimental-allow-non-resilient-access is passed and built
+  /// from source.
+  bool AllowNonResilientAccess = false;
+
   /// Should we warn if an imported module needed to be rebuilt from a
   /// module interface file?
   bool RemarkOnRebuildFromModuleInterface = false;

include/swift/Option/Options.td

@@ -524,6 +524,10 @@ def experimental_package_bypass_resilience : Flag<["-"], "experimental-package-b
   Flags<[FrontendOption]>,
   HelpText<"Enable optimization to bypass resilience within a package">;
 
+def experimental_allow_non_resilient_access : Flag<["-"], "experimental-allow-non-resilient-access">,
+  Flags<[FrontendOption]>,
+  HelpText<"Allow non-resilient access by generating all contents besides exportable decls">;
+
 def library_level : Separate<["-"], "library-level">,
   MetaVarName<"<level>">,
   Flags<[HelpHidden, FrontendOption, ModuleInterfaceOption]>,

include/swift/Serialization/Validation.h

@@ -144,6 +144,7 @@ class ExtendedValidationInfo {
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
     unsigned IsConcurrencyChecked : 1;
     unsigned HasCxxInteroperability : 1;
+    unsigned AllowNonResilientAccess: 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -208,6 +209,10 @@ class ExtendedValidationInfo {
   void setIsBuiltFromInterface(bool val) {
     Bits.IsBuiltFromInterface = val;
   }
+  bool allowNonResilientAccess() const { return Bits.AllowNonResilientAccess; }
+  void setAllowNonResilientAccess(bool val) {
+    Bits.AllowNonResilientAccess = val;
+  }
   bool isAllowModuleWithCompilerErrorsEnabled() {
     return Bits.IsAllowModuleWithCompilerErrorsEnabled;
   }

lib/AST/Decl.cpp

@@ -4214,9 +4214,13 @@ bool ValueDecl::hasOpenAccess(const DeclContext *useDC) const {
 }
 
 bool ValueDecl::bypassResilienceInPackage(ModuleDecl *accessingModule) const {
+  // Client needs to opt in to bypass resilience checks at the use site.
+  // Client and the loaded module both need to be in the same package.
+  // The loaded module needs to be built from source and opt in to allow
+  // non-resilient access.
   return getASTContext().LangOpts.EnableBypassResilienceInPackage &&
          getModuleContext()->inSamePackage(accessingModule) &&
-         !getModuleContext()->isBuiltFromInterface();
+         getModuleContext()->allowNonResilientAccess();
 }
 
 /// Given the formal access level for using \p VD, compute the scope where

lib/AST/Module.cpp

@@ -722,6 +722,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.IsConcurrencyChecked = 0;
   Bits.ModuleDecl.ObjCNameLookupCachePopulated = 0;
   Bits.ModuleDecl.HasCxxInteroperability = 0;
+  Bits.ModuleDecl.AllowNonResilientAccess = 0;
 }
 
 void ModuleDecl::setIsSystemModule(bool flag) {

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -314,6 +314,26 @@ bool ArgsToFrontendOptionsConverter::convert(
                      "-enable-library-evolution");
   }
 
+  Opts.AllowNonResilientAccess = Args.hasArg(OPT_experimental_allow_non_resilient_access);
+  if (Opts.AllowNonResilientAccess) {
+    // Override the option to skip non-exportable decls.
+    if (Opts.SkipNonExportableDecls) {
+      Diags.diagnose(SourceLoc(), diag::warn_ignore_option_overriden_by,
+                     "-experimental-skip-non-exportable-decls",
+                     "-experimental-allow-non-resilient-access");
+      Opts.SkipNonExportableDecls = false;
+    }
+    // If built from interface, non-resilient access should not be allowed.
+    if (Opts.AllowNonResilientAccess &&
+        (Opts.RequestedAction == FrontendOptions::ActionType::CompileModuleFromInterface ||
+         Opts.RequestedAction == FrontendOptions::ActionType::TypecheckModuleFromInterface)) {
+      Diags.diagnose(SourceLoc(), diag::warn_ignore_option_overriden_by,
+                     "-experimental-allow-non-resilient-access",
+                     "-compile-module-from-interface or -typecheck-module-from-interface");
+      Opts.AllowNonResilientAccess = false;
+    }
+  }
+
   // HACK: The driver currently erroneously passes all flags to module interface
   // verification jobs. -experimental-skip-non-exportable-decls is not
   // appropriate for verification tasks and should be ignored, though.

lib/Frontend/Frontend.cpp

@@ -1402,6 +1402,8 @@ ModuleDecl *CompilerInstance::getMainModule() const {
     if (Invocation.getLangOptions().EnableCXXInterop &&
         Invocation.getLangOptions().RequireCxxInteropToImportCxxInteropModule)
       MainModule->setHasCxxInteroperability();
+    if (Invocation.getFrontendOptions().AllowNonResilientAccess)
+      MainModule->setAllowNonResilientAccess();
 
     // Register the main module with the AST context.
     Context->addLoadedModule(MainModule);