DependenciesScanner: prefer private Swift module interfaces if present

nkcsgexi · nkcsgexi · commit 5c9b737c89b9 · 2020-08-18T13:09:07.000-07:00
rdar://67257185
diff --git a/include/swift/AST/ModuleLoader.h b/include/swift/AST/ModuleLoader.h
@@ -24,6 +24,7 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "swift/AST/ModuleDependencies.h"
+#include <system_error>
 
 namespace llvm {
 class FileCollector;
@@ -103,17 +104,18 @@ struct SubCompilerInstanceInfo {
 
 /// Abstract interface to run an action in a sub ASTContext.
 struct InterfaceSubContextDelegate {
-  virtual bool runInSubContext(StringRef moduleName,
-                               StringRef interfacePath,
-                               StringRef outputPath,
-                               SourceLoc diagLoc,
-  llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
-                          ArrayRef<StringRef>, StringRef)> action) = 0;
-  virtual bool runInSubCompilerInstance(StringRef moduleName,
-                                        StringRef interfacePath,
-                                        StringRef outputPath,
-                                        SourceLoc diagLoc,
-                    llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) = 0;
+  virtual std::error_code runInSubContext(StringRef moduleName,
+                                          StringRef interfacePath,
+                                          StringRef outputPath,
+                                          SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*,
+                                       ArrayRef<StringRef>,
+                                       ArrayRef<StringRef>, StringRef)> action) = 0;
+  virtual std::error_code runInSubCompilerInstance(StringRef moduleName,
+                                                   StringRef interfacePath,
+                                                   StringRef outputPath,
+                                                   SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) = 0;
 
   virtual ~InterfaceSubContextDelegate() = default;
 };
diff --git a/include/swift/Frontend/ModuleInterfaceLoader.h b/include/swift/Frontend/ModuleInterfaceLoader.h
@@ -415,17 +415,18 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                                   StringRef prebuiltCachePath,
                                   bool serializeDependencyHashes,
                                   bool trackSystemDependencies);
-  bool runInSubContext(StringRef moduleName,
-                       StringRef interfacePath,
-                       StringRef outputPath,
-                       SourceLoc diagLoc,
-    llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
-                            ArrayRef<StringRef>, StringRef)> action) override;
-  bool runInSubCompilerInstance(StringRef moduleName,
-                                StringRef interfacePath,
-                                StringRef outputPath,
-                                SourceLoc diagLoc,
-            llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
+  std::error_code runInSubContext(StringRef moduleName,
+                                  StringRef interfacePath,
+                                  StringRef outputPath,
+                                  SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*,
+                                       ArrayRef<StringRef>, ArrayRef<StringRef>,
+                                       StringRef)> action) override;
+  std::error_code runInSubCompilerInstance(StringRef moduleName,
+                                           StringRef interfacePath,
+                                           StringRef outputPath,
+                                           SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) override;
 
   ~InterfaceSubContextDelegateImpl() = default;
 
diff --git a/lib/Frontend/ModuleInterfaceBuilder.cpp b/lib/Frontend/ModuleInterfaceBuilder.cpp
@@ -161,10 +161,10 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
       llvm::RestorePrettyStackState(savedInnerPrettyStackState);
     };
 
-    SubError = subASTDelegate.runInSubCompilerInstance(moduleName,
-                                                       interfacePath,
-                                                       OutPath,
-                                                       diagnosticLoc,
+    SubError = (bool)subASTDelegate.runInSubCompilerInstance(moduleName,
+                                                             interfacePath,
+                                                             OutPath,
+                                                             diagnosticLoc,
                                            [&](SubCompilerInstanceInfo &info) {
     auto &SubInstance = *info.Instance;
     auto subInvocation = SubInstance.getInvocation();
@@ -173,7 +173,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
         .getModuleInterfaceLoader())->tryEmitForwardingModule(moduleName,
                                                               interfacePath,
                                                   CompiledCandidates, OutPath)) {
-      return false;
+      return std::error_code();
     }
     FrontendOptions &FEOpts = subInvocation.getFrontendOptions();
     const auto &InputInfo = FEOpts.InputsAndOutputs.firstInput();
@@ -208,7 +208,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     SubInstance.performSema();
     if (SubInstance.getASTContext().hadError()) {
       LLVM_DEBUG(llvm::dbgs() << "encountered errors\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
 
     SILOptions &SILOpts = subInvocation.getSILOptions();
@@ -217,7 +217,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     auto SILMod = performASTLowering(Mod, TC, SILOpts);
     if (!SILMod) {
       LLVM_DEBUG(llvm::dbgs() << "SILGen did not produce a module\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
 
     // Setup the callbacks for serialization, which can occur during the
@@ -237,7 +237,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     SmallVector<FileDependency, 16> Deps;
     bool serializeHashes = FEOpts.SerializeModuleInterfaceDependencyHashes;
     if (collectDepsForSerialization(SubInstance, Deps, serializeHashes)) {
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
     if (ShouldSerializeDeps)
       SerializationOpts.Dependencies = Deps;
@@ -253,9 +253,12 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     LLVM_DEBUG(llvm::dbgs() << "Running SIL processing passes\n");
     if (SubInstance.performSILProcessing(SILMod.get())) {
       LLVM_DEBUG(llvm::dbgs() << "encountered errors\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
+    }
+    if (SubInstance.getDiags().hadAnyError()) {
+      return std::make_error_code(std::errc::not_supported);
     }
-    return SubInstance.getDiags().hadAnyError();
+    return std::error_code();
     });
   });
   return !RunSuccess || SubError;
diff --git a/lib/Frontend/ModuleInterfaceLoader.cpp b/lib/Frontend/ModuleInterfaceLoader.cpp
@@ -1393,11 +1393,12 @@ InterfaceSubContextDelegateImpl::getCacheHash(StringRef useInterfacePath) {
   return llvm::APInt(64, H).toString(36, /*Signed=*/false);
 }
 
-bool InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
-                                                      StringRef interfacePath,
-                                                      StringRef outputPath,
-                                                      SourceLoc diagLoc,
-    llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
+std::error_code
+InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
+                                                 StringRef interfacePath,
+                                                 StringRef outputPath,
+                                                 SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
                             ArrayRef<StringRef>, StringRef)> action) {
   return runInSubCompilerInstance(moduleName, interfacePath, outputPath, diagLoc,
                                   [&](SubCompilerInstanceInfo &info){
@@ -1409,11 +1410,12 @@ bool InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
   });
 }
 
-bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
-                                                               StringRef interfacePath,
-                                                               StringRef outputPath,
-                                                               SourceLoc diagLoc,
-                  llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) {
+std::error_code
+InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
+                                                          StringRef interfacePath,
+                                                          StringRef outputPath,
+                                                          SourceLoc diagLoc,
+                  llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) {
   // We are about to mess up the compiler invocation by using the compiler
   // arguments in the textual interface file. So copy to use a new compiler
   // invocation.
@@ -1457,12 +1459,12 @@ bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleN
                                           CompilerVersion,
                                           interfacePath,
                                           diagLoc)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   // Insert arguments collected from the interface file.
   BuildArgs.insert(BuildArgs.end(), SubArgs.begin(), SubArgs.end());
   if (subInvocation.parseArgs(SubArgs, Diags)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   CompilerInstance subInstance;
   SubCompilerInstanceInfo info;
@@ -1474,7 +1476,7 @@ bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleN
   ForwardingDiagnosticConsumer FDC(Diags);
   subInstance.addDiagnosticConsumer(&FDC);
   if (subInstance.setup(subInvocation)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   info.BuildArguments = BuildArgs;
   info.Hash = CacheHash;
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
@@ -81,6 +81,12 @@ class ModuleDependencyScanner : public SerializedModuleLoaderBase {
       }
     }
     assert(fs.exists(InPath));
+    // Use the private interface file if exits.
+    auto PrivateInPath =
+      BaseName.getName(file_types::TY_PrivateSwiftModuleInterfaceFile);
+    if (fs.exists(PrivateInPath)) {
+      InPath = PrivateInPath;
+    }
     auto dependencies = scanInterfaceFile(InPath, IsFramework);
     if (dependencies) {
       this->dependencies = std::move(dependencies.get());
@@ -182,9 +188,8 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
   llvm::SmallString<32> modulePath = moduleName.str();
   llvm::sys::path::replace_extension(modulePath, newExt);
   Optional<ModuleDependencies> Result;
-  std::error_code code;
-
-  auto hasError = astDelegate.runInSubContext(moduleName.str(),
+  std::error_code code =
+    astDelegate.runInSubContext(moduleName.str(),
                                               moduleInterfacePath.str(),
                                               StringRef(),
                                               SourceLoc(),
@@ -205,8 +210,7 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
     auto &fs = *Ctx.SourceMgr.getFileSystem();
     auto interfaceBuf = fs.getBufferForFile(moduleInterfacePath);
     if (!interfaceBuf) {
-      code = interfaceBuf.getError();
-      return true;
+      return interfaceBuf.getError();
     }
 
     // Create a source file.
@@ -225,10 +229,10 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
     for (auto name: imInfo.ModuleNames) {
       Result->addModuleDependency(name.str(), &alreadyAddedModules);
     }
-    return false;
+    return std::error_code();
   });
 
-  if (hasError) {
+  if (code) {
     return code;
   }
   return *Result;
diff --git a/test/ScanDependencies/module_deps_private_interface.swift b/test/ScanDependencies/module_deps_private_interface.swift
@@ -0,0 +1,16 @@
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/clang-module-cache
+// RUN: echo "// swift-interface-format-version: 1.0" > %t/Foo.swiftinterface
+// RUN: echo "// swift-module-flags: -module-name Foo" >> %t/Foo.swiftinterface
+// RUN: echo "public func foo() {}" >> %t/Foo.swiftinterface
+
+// RUN: cp %t/Foo.swiftinterface %t/Foo.private.swiftinterface
+
+// RUN: %target-swift-frontend -scan-dependencies -module-cache-path %t/clang-module-cache %s -o %t/deps.json -I %t -disable-implicit-swift-modules -Xcc -Xclang -Xcc -fno-implicit-modules
+
+// Check the contents of the JSON output
+// RUN: %FileCheck %s < %t/deps.json
+
+import Foo
+
+// CHECK: "moduleInterfacePath": "{{.*}}Foo.private.swiftinterface",
