Frontend: Introduce -experimental-serialize-external-decls-only option.

This option is designed to be used in conjunction with
`-experimental-lazy-typecheck` and `-experimental-skip-all-function-bodies`
when emitting a resilient module. The emitted binary module should contain only
the decls needed by clients and should contain roughly the same contents as it
would if the corresponding swiftinterface were emitted instead and then built.

This functionality is a work in progress. Some parts of the AST may still get
typechecked unnecessarily. Additionally, serialization does not trigger the
appropriate typechecking requests for some ASTs and then fails due to missing
types.

Resolves rdar://114230586

Author: tshortli

include/swift/Frontend/FrontendOptions.h

@@ -267,7 +267,6 @@ class FrontendOptions {
   /// \see ModuleDecl::arePrivateImportsEnabled
   bool EnablePrivateImports = false;
 
-
   /// Indicates whether we add implicit dynamic.
   ///
   /// \see ModuleDecl::isImplicitDynamicEnabled
@@ -322,6 +321,10 @@ class FrontendOptions {
   /// times) when compiling a module interface?
   bool SerializeModuleInterfaceDependencyHashes = false;
 
+  /// Should we only serialize decls that may be referenced externally in the
+  /// binary module?
+  bool SerializeExternalDeclsOnly = false;
+
   /// Should we warn if an imported module needed to be rebuilt from a
   /// module interface file?
   bool RemarkOnRebuildFromModuleInterface = false;

include/swift/Option/FrontendOptions.td

@@ -166,6 +166,10 @@ def serialize_debugging_options : Flag<["-"], "serialize-debugging-options">,
 def serialized_path_obfuscate : Separate<["-"], "serialized-path-obfuscate">,
     HelpText<"Remap source paths in debug info">, MetaVarName<"<prefix=replacement>">;
 
+def experimental_serialize_external_decls_only
+  : Flag<["-"], "experimental-serialize-external-decls-only">,
+  HelpText<"Only serialize decls that should be exposed to clients">;
+
 def empty_abi_descriptor : Flag<["-"], "empty-abi-descriptor">,
   HelpText<"Avoid printing actual module content into ABI descriptor file">;
 

include/swift/Serialization/SerializationOptions.h

@@ -156,6 +156,7 @@ namespace swift {
     bool StaticLibrary = false;
     bool HermeticSealAtLink = false;
     bool IsOSSA = false;
+    bool SerializeExternalDeclsOnly = false;
   };
 
 } // end namespace swift

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -318,6 +318,8 @@ bool ArgsToFrontendOptionsConverter::convert(
         A->getOption().matches(OPT_serialize_debugging_options);
   }
 
+  Opts.SerializeExternalDeclsOnly |=
+      Args.hasArg(OPT_experimental_serialize_external_decls_only);
   Opts.DebugPrefixSerializedDebuggingOptions |=
       Args.hasArg(OPT_prefix_serialized_debugging_options);
   Opts.EnableSourceImport |= Args.hasArg(OPT_enable_source_import);

lib/Frontend/Frontend.cpp

@@ -225,6 +225,9 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
 
   serializationOpts.IsOSSA = getSILOptions().EnableOSSAModules;
 
+  serializationOpts.SerializeExternalDeclsOnly =
+      opts.SerializeExternalDeclsOnly;
+
   return serializationOpts;
 }
 

lib/Serialization/Serialization.cpp

@@ -3258,6 +3258,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     }
   }
 
+public:
   /// Determine if \p decl is safe to deserialize when it's public
   /// or otherwise needed by the client in normal builds, this should usually
   /// correspond to logic in type-checking ensuring these safe decls don't
@@ -3336,6 +3337,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     return false;
   }
 
+private:
   /// Write a \c DeserializationSafetyLayout record only when \p decl is unsafe
   /// to deserialize.
   ///
@@ -3505,6 +3507,9 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
     SmallVector<DeclID, 16> memberIDs;
     for (auto member : members) {
+      if (S.shouldSkipDecl(member))
+        continue;
+
       if (!shouldSerializeMember(member))
         continue;
 
@@ -4888,6 +4893,14 @@ static bool canSkipWhenInvalid(const Decl *D) {
   return false;
 }
 
+bool Serializer::shouldSkipDecl(const Decl *D) const {
+  if (Options.SerializeExternalDeclsOnly &&
+      !DeclSerializer::isDeserializationSafe(D))
+    return true;
+
+  return false;
+}
+
 void Serializer::writeASTBlockEntity(const Decl *D) {
   using namespace decls_block;
 
@@ -6358,6 +6371,9 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
         continue;
       }
 
+      if (shouldSkipDecl(D))
+        continue;
+
       if (auto VD = dyn_cast<ValueDecl>(D)) {
         if (!VD->hasName())
           continue;
@@ -6406,6 +6422,8 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
     nextFile->getOpaqueReturnTypeDecls(opaqueReturnTypeDecls);
 
     for (auto TD : localTypeDecls) {
+      if (shouldSkipDecl(TD))
+        continue;
 
       // FIXME: We should delay parsing function bodies so these type decls
       //        don't even get added to the file.
@@ -6436,6 +6454,9 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
     }
 
     for (auto OTD : opaqueReturnTypeDecls) {
+      if (shouldSkipDecl(OTD))
+        continue;
+
       // FIXME: We should delay parsing function bodies so these type decls
       //        don't even get added to the file.
       if (OTD->getDeclContext()->getInnermostSkippedFunctionContext())

lib/Serialization/Serialization.h

@@ -332,6 +332,9 @@ class Serializer : public SerializerBase {
   /// Check if a decl is cross-referenced.
   bool isDeclXRef(const Decl *D) const;
 
+  /// Check if a decl should be skipped during serialization.
+  bool shouldSkipDecl(const Decl *D) const;
+
   /// Writes a reference to a decl in another module.
   void writeCrossReference(const DeclContext *DC, uint32_t pathLen = 1);
 

test/Driver/emit-interface.swift

@@ -26,9 +26,3 @@
 // CHECK-FILELIST: swift{{(-frontend|c)?(\.exe)?"?}} -frontend
 // CHECK-FILELIST-SAME: -supplementary-output-file-map
 // CHECK-FILELIST-NOT: emit-interface.swift{{ }}
-
-// RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 -experimental-lazy-typecheck %s -emit-module-interface -o %t/foo 2>&1 | %FileCheck -check-prefix=CHECK-LAZY-TYPECHECK %s
-
-// CHECK-LAZY-TYPECHECK: swift{{(-frontend|c)?(\.exe)?"?}} -frontend
-// CHECK-LAZY-TYPECHECK-SAME: -experimental-lazy-typecheck
-// CHECK-LAZY-TYPECHECK-SAME: emit-interface.swift

test/Inputs/lazy_typecheck.swift

@@ -0,0 +1,81 @@
+// This source file contains intentional type checking errors that should be
+// avoided when compiling with -experimental-lazy-typecheck and emitting module
+// outputs since all the errors occur in regions of the AST that do not
+// need to be type checked in order to emit a module or module interface.
+
+// MARK: - Global functions
+
+public func publicFunc() -> Int {
+  return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+}
+
+public func publicFuncWithDefaultArg(_ x: Int = 1) -> Int {
+  return doesNotExist() // expected-error {{cannot find 'doesNotExist' in scope}}
+}
+
+package func packageFunc() -> Int {
+  return false // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+}
+
+func internalFunc() -> DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
+  return 1
+}
+
+@inlinable func inlinableFunc() -> Int {
+  return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+}
+
+private func privateFunc() -> DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
+  return 1
+}
+
+public func constrainedGenericPublicFunction<T>(_ t: T) where T: PublicProto {
+  doesNotExist() // expected-error {{cannot find 'doesNotExist' in scope}}
+}
+
+@available(SwiftStdlib 5.1, *)
+public func publicFuncWithOpaqueReturnType() -> some PublicProto { // expected-note {{opaque return type declared here}}
+  return 1 // expected-error {{return type of global function 'publicFuncWithOpaqueReturnType()' requires that 'Int' conform to 'PublicProto'}}
+}
+
+@available(SwiftStdlib 5.1, *)
+@_alwaysEmitIntoClient public func publicAEICFuncWithOpaqueReturnType() -> some Any {
+  if #available(macOS 20, *) {
+    return 3
+  } else {
+    return "hi"
+  }
+}
+
+// MARK: - Nominal types
+
+public protocol PublicProto {
+  func req() -> Int
+}
+
+protocol InternalProto {
+  // FIXME: Serialization causes typechecking of protocols regardless of access level
+//  func req() -> DoesNotExist
+}
+
+public struct PublicStruct {
+  // FIXME: Test properties
+
+  public func publicMethod() -> Int {
+    return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+  }
+
+  func internalMethod() -> DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
+    return 1
+  }
+}
+
+struct InternalStruct: DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
+  var x: DoesNotExist // expected-error {{cannot find type 'DoesNotExist' in scope}}
+
+  func f(_ x: DoesNotExist) {} // expected-error {{cannot find type 'DoesNotExist' in scope}}
+}
+
+// FIXME: Test enums
+// FIXME: Test conformances
+// FIXME: Test global vars

test/Serialization/serialize-external-decls-only-lazy-typecheck.swift

@@ -0,0 +1,25 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -swift-version 5 %S/../Inputs/lazy_typecheck.swift -enable-library-evolution -parse-as-library -package-name Package -typecheck -verify
+// RUN: %target-swift-frontend -swift-version 5 %S/../Inputs/lazy_typecheck.swift -module-name lazy_typecheck -emit-module -emit-module-path %t/lazy_typecheck.swiftmodule -enable-library-evolution -parse-as-library -package-name Package -experimental-lazy-typecheck -experimental-skip-all-function-bodies -experimental-serialize-external-decls-only
+// RUN: %target-swift-frontend -package-name Package -typecheck %s -I %t
+
+import lazy_typecheck
+
+struct ConformsToPublicProto: PublicProto {
+  func req() -> Int { return 1 }
+}
+
+func testGlobalFunctions() {
+  _ = publicFunc()
+  _ = publicFuncWithDefaultArg()
+  _ = packageFunc()
+  constrainedGenericPublicFunction(ConformsToPublicProto())
+  if #available(SwiftStdlib 5.1, *) {
+    _ = publicFuncWithOpaqueReturnType()
+    _ = publicAEICFuncWithOpaqueReturnType()
+  }
+}
+
+func testPublicStruct(_ s: PublicStruct) {
+  _ = s.publicMethod()
+}