[Serialization] Always serialize module-defining '.swiftinterface', even if SDK-relative.

The clients, upon loading, will resolve the SDK-relative path to their SDK location.

Resolves rdar://120673684

Author: artemcm

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -275,10 +275,12 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
       !Invocation.getIRGenOptions().ForceLoadSymbolName.empty();
   SerializationOpts.UserModuleVersion = FEOpts.UserModuleVersion;
   SerializationOpts.AllowableClients = FEOpts.AllowableClients;
-
-  // Record any non-SDK module interface files for the debug info.
   StringRef SDKPath = Instance.getASTContext().SearchPathOpts.getSDKPath();
-  if (!getRelativeDepPath(InPath, SDKPath))
+
+  auto SDKRelativePath = getRelativeDepPath(InPath, SDKPath);
+  if (SDKRelativePath.has_value())
+    SerializationOpts.ModuleInterface = SDKRelativePath.value();
+  else
     SerializationOpts.ModuleInterface = InPath;
 
   SerializationOpts.SDKName = Instance.getASTContext().LangOpts.SDKName;

lib/Serialization/ModuleFile.cpp

@@ -91,6 +91,19 @@ static bool isTargetTooNew(const llvm::Triple &moduleTarget,
   return ctxTarget.isOSVersionLT(moduleTarget);
 }
 
+std::string ModuleFile::resolveModuleDefiningFilename(const ASTContext &ctx) {
+  if (!Core->ModuleInterfacePath.empty()) {
+    std::string interfacePath = Core->ModuleInterfacePath.str();
+    if (llvm::sys::path::is_relative(interfacePath)) {
+      SmallString<128> absoluteInterfacePath(ctx.SearchPathOpts.getSDKPath());
+      llvm::sys::path::append(absoluteInterfacePath, interfacePath);
+      return absoluteInterfacePath.str().str();
+    } else
+      return interfacePath;
+  } else
+    return getModuleLoadedFilename().str();
+}
+
 namespace swift {
 namespace serialization {
 bool areCompatible(const llvm::Triple &moduleTarget,
@@ -257,6 +270,8 @@ Status ModuleFile::associateWithFileContext(FileUnit *file, SourceLoc diagLoc,
   }
 
   ASTContext &ctx = getContext();
+  // Resolve potentially-SDK-relative module-defining .swiftinterface path
+  ResolvedModuleDefiningFilename = resolveModuleDefiningFilename(ctx);
 
   llvm::Triple moduleTarget(llvm::Triple::normalize(Core->TargetTriple));
   if (!areCompatible(moduleTarget, ctx.LangOpts.Target)) {

lib/Serialization/ModuleFile.h

@@ -74,6 +74,11 @@ class ModuleFile
   /// The module that this module is an overlay of, if any.
   ModuleDecl *UnderlyingModule = nullptr;
 
+  /// Once this module file has been associated with the AST node representing
+  /// it, resolve the potentially-SDK-relative module-defining `.swiftinterface`
+  /// path to an absolute path.
+  llvm::Optional<std::string> ResolvedModuleDefiningFilename;
+
   /// The cursor used to lazily load things from the file.
   llvm::BitstreamCursor DeclTypeCursor;
 
@@ -280,6 +285,10 @@ class ModuleFile
   ArrayRef<ProtocolConformanceID>
   claimLazyConformanceLoaderToken(uint64_t token);
 
+  /// If the module-defining `.swiftinterface` file is an SDK-relative path,
+  /// resolve it to be absolute to the context's SDK.
+  std::string resolveModuleDefiningFilename(const ASTContext &ctx);
+
   /// Represents an identifier that may or may not have been deserialized yet.
   ///
   /// If \c Ident is empty, the identifier has not been loaded yet.
@@ -849,6 +858,8 @@ class ModuleFile
   void getDisplayDecls(SmallVectorImpl<Decl*> &results, bool recursive = false);
 
   StringRef getModuleFilename() const {
+    if (ResolvedModuleDefiningFilename)
+      return ResolvedModuleDefiningFilename.value();
     if (!Core->ModuleInterfacePath.empty())
       return Core->ModuleInterfacePath;
     return getModuleLoadedFilename();

test/Serialization/module_defining_interface.swift

@@ -0,0 +1,28 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t/inputs)
+// RUN: %empty-directory(%t/test-sdk)
+// RUN: %empty-directory(%t/test-sdk/usr/lib/Foo.swiftmodule)
+// RUN: split-file %s %t
+
+// --- Verify that a non-SDK module gets its absolute path serialized into the binary '.swiftmodule'
+// RUN: %target-swift-frontend -compile-module-from-interface -module-name Foo %t/modules/Foo.swiftinterface -o %t/inputs/Foo.swiftmodule
+// RUN: llvm-bcanalyzer -dump %t/inputs/Foo.swiftmodule > %t/Foo.freestanding.moduledump.txt
+// RUN: cat %t/Foo.freestanding.moduledump.txt | %FileCheck %s -check-prefix CHECK-FREESTANDING-FOO
+
+// --- Verify that an SDK module gets its SDK-relative path serialized into the binary '.swiftmodule'
+// RUN: cp %t/modules/Foo.swiftinterface %t/test-sdk/usr/lib/Foo.swiftmodule
+// RUN: %target-swift-frontend(mock-sdk: -sdk %t/test-sdk) -compile-module-from-interface -module-name Foo %t/test-sdk/usr/lib/Foo.swiftmodule/Foo.swiftinterface -o %t/inputs/SDKFoo.swiftmodule
+// RUN: llvm-bcanalyzer -dump %t/inputs/SDKFoo.swiftmodule > %t/Foo.sdk.moduledump.txt
+// RUN: cat %t/Foo.SDK.moduledump.txt | %FileCheck %s -check-prefix CHECK-SDK-FOO
+
+// CHECK-FREESTANDING-FOO: <MODULE_INTERFACE_PATH abbrevid={{[0-9]+}}/> blob data = '{{.*}}{{/|\\}}modules{{/|\\}}Foo.swiftinterface'
+// CHECK-SDK-FOO: <MODULE_INTERFACE_PATH abbrevid={{[0-9]+}}/> blob data = 'usr/lib/Foo.swiftmodule/Foo.swiftinterface'
+
+//--- modules/Foo.swiftinterface
+// swift-interface-format-version: 1.0
+// swift-module-flags: -module-name Foo
+public func foo()
+
+//--- File.swift
+import Foo
+public func bar() { foo() }