Opt in to generate internal contents in module and allow non-resilient access by clients

Author: elsh

include/swift/AST/Decl.h

@@ -752,9 +752,8 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     /// Whether this module has been built with C++ interoperability enabled.
     HasCxxInteroperability : 1,
 
-    /// Whether this module has been built with -experimental-skip-non-exportable-decls
-    /// or -experimental-skip-non-inlinable-function-bodies.
-    OnlyHasExportableDecls : 1
+    /// Whether this module has been built with -experimental-allow-non-resilient-access.
+    AllowNonResilientAccess : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

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_due_to_conflict,none,
+        "ignoring %0 (conflicts with %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,13 +711,12 @@ class ModuleDecl
     Bits.ModuleDecl.IsBuiltFromInterface = flag;
   }
 
-  /// Returns true if the module was built with -experimental-skip-non-exportable-decls
-  /// or -experimental-skip-non-inlinable-function-bodies.
-  bool onlyHasExportableDecls() const {
-    return Bits.ModuleDecl.OnlyHasExportableDecls;
+  /// Returns true if the module was built with -experimental-allow-non-resilient-access.
+  bool allowNonResilientAccess() const {
+    return Bits.ModuleDecl.AllowNonResilientAccess;
   }
-  void setOnlyHasExportableDecls(bool flag = true) {
-    Bits.ModuleDecl.OnlyHasExportableDecls = flag;
+  void setAllowNonResilientAccess(bool flag = true) {
+    Bits.ModuleDecl.AllowNonResilientAccess = flag;
   }
 
   /// Returns true if this module is a non-Swift module that was imported into

include/swift/Frontend/FrontendOptions.h

@@ -311,6 +311,11 @@ 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
+  /// without -enable-library-evolution. This overrides \c SkipNonExportableDecls
+  /// (-experimental-skip-non-exportable-decls).
+  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

@@ -140,7 +140,7 @@ class ExtendedValidationInfo {
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
     unsigned IsConcurrencyChecked : 1;
     unsigned HasCxxInteroperability : 1;
-    unsigned OnlyHasExportableDecls: 1;
+    unsigned AllowNonResilientAccess: 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -205,9 +205,9 @@ class ExtendedValidationInfo {
   void setIsBuiltFromInterface(bool val) {
     Bits.IsBuiltFromInterface = val;
   }
-  bool onlyHasExportableDecls() const { return Bits.OnlyHasExportableDecls; }
-  void setOnlyHasExportableDecls(bool val) {
-    Bits.OnlyHasExportableDecls = val;
+  bool allowNonResilientAccess() const { return Bits.AllowNonResilientAccess; }
+  void setAllowNonResilientAccess(bool val) {
+    Bits.AllowNonResilientAccess = val;
   }
   bool isAllowModuleWithCompilerErrorsEnabled() {
     return Bits.IsAllowModuleWithCompilerErrorsEnabled;

lib/AST/Decl.cpp

@@ -4217,8 +4217,7 @@ bool ValueDecl::bypassResilienceInPackage(ModuleDecl *accessingModule) const {
   return getASTContext().LangOpts.EnableBypassResilienceInPackage &&
          getModuleContext()->inSamePackage(accessingModule) &&
          !getModuleContext()->isBuiltFromInterface() &&
-         !getModuleContext()->onlyHasExportableDecls() &&
-         !getModuleContext()->isTestingEnabled();
+         !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

@@ -295,7 +295,22 @@ bool ArgsToFrontendOptionsConverter::convert(
         A->getOption().matches(OPT_serialize_debugging_options);
   }
 
+  // To allow non-resilient access from clients, internal contents
+  // besides exportable decls should be generated. If built from
+  // interface, or with -enable-library-evolution, we ignore this
+  // option (-experimental-allow-non-resilient-access). This option
+  // will however override -experimental-skip-non-exportable-decls
+  // if both are passed.
+  Opts.AllowNonResilientAccess = Args.hasArg(OPT_experimental_allow_non_resilient_access);
+
   if (Args.hasArg(OPT_enable_library_evolution)) {
+    if (Opts.AllowNonResilientAccess) {
+      Diags.diagnose(SourceLoc(), diag::warn_ignore_option_due_to_conflict,
+                     "-experimental-allow-non-resilient-access",
+                     "-enable-library-evolution");
+      Opts.AllowNonResilientAccess = false;
+    }
+
     Opts.SkipNonExportableDecls |=
         Args.hasArg(OPT_experimental_skip_non_exportable_decls);
 
@@ -304,10 +319,26 @@ bool ArgsToFrontendOptionsConverter::convert(
         Args.hasArg(
             OPT_experimental_skip_non_inlinable_function_bodies_is_lazy);
   } else {
-    if (Args.hasArg(OPT_experimental_skip_non_exportable_decls))
+    if (Args.hasArg(OPT_experimental_skip_non_exportable_decls)) {
       Diags.diagnose(SourceLoc(), diag::ignoring_option_requires_option,
                      "-experimental-skip-non-exportable-decls",
                      "-enable-library-evolution");
+      if (Opts.AllowNonResilientAccess) {
+        Diags.diagnose(SourceLoc(), diag::warn_ignore_option_due_to_conflict,
+                       "-experimental-skip-non-exportable-decls",
+                       "-experimental-allow-non-resilient-access");
+      }
+    }
+  }
+
+  // To allow non-resilient access from clients, it should be built from source.
+  if (Opts.AllowNonResilientAccess &&
+      (Opts.RequestedAction == FrontendOptions::ActionType::CompileModuleFromInterface ||
+       Opts.RequestedAction == FrontendOptions::ActionType::TypecheckModuleFromInterface)) {
+    Diags.diagnose(SourceLoc(), diag::warn_ignore_option_due_to_conflict,
+                   "-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

lib/Frontend/CompilerInvocation.cpp

@@ -2123,11 +2123,15 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
 
   // Propagate the typechecker's understanding of
   // -experimental-skip-*-function-bodies to SIL.
-  Opts.SkipFunctionBodies = TCOpts.SkipFunctionBodies;
+  // Only set if -experimental-allow-non-resilient-access
+  // is not passed.
+  Opts.SkipFunctionBodies = FEOpts.AllowNonResilientAccess ? FunctionBodySkipping::None : TCOpts.SkipFunctionBodies;
 
   // Propagate -experimental-skip-non-exportable-decls to SIL.
-  Opts.SkipNonExportableDecls = FEOpts.SkipNonExportableDecls;
-
+  // Only set if -experimental-allow-non-resilient-access is
+  // not passed.
+  Opts.SkipNonExportableDecls = FEOpts.AllowNonResilientAccess ? false : FEOpts.SkipNonExportableDecls;
+  
   // Parse the optimization level.
   // Default to Onone settings if no option is passed.
   Opts.OptMode = OptimizationMode::NoOptimization;