Factor out reading flags/version from an interface from setting up a Compiler sub-instance

Author: artemcm

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -453,7 +453,7 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
       const StringRef backupInterfaceDir, const StringRef prebuiltCachePath,
       const StringRef ABIDescriptorPath, StringRef interfacePath,
       StringRef outputPath, bool ShouldSerializeDeps,
-      ArrayRef<std::string> CompiledCandidates, StringRef CompilerVersion,
+      ArrayRef<std::string> CompiledCandidates,
       DependencyTracker *tracker = nullptr);
 };
 
@@ -473,13 +473,8 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
   InFlightDiagnostic diagnose(StringRef interfacePath,
                               SourceLoc diagnosticLoc,
                               Diag<ArgTypes...> ID,
-                        typename detail::PassArgument<ArgTypes>::type... Args) {
-    SourceLoc loc = diagnosticLoc;
-    if (diagnosticLoc.isInvalid()) {
-      // Diagnose this inside the interface file, if possible.
-      loc = SM.getLocFromExternalSource(interfacePath, 1, 1);
-    }
-    return Diags->diagnose(loc, ID, std::move(Args)...);
+                              typename detail::PassArgument<ArgTypes>::type... Args) {
+    return InterfaceSubContextDelegateImpl::diagnose(interfacePath, diagnosticLoc, SM, Diags, ID, std::move(Args)...);
   }
   void
   inheritOptionsForBuildingInterface(const SearchPathOptions &SearchPathOpts,
@@ -500,6 +495,22 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
       StringRef backupModuleInterfaceDir,
       bool serializeDependencyHashes, bool trackSystemDependencies,
       RequireOSSAModules_t requireOSSAModules);
+
+  template<typename ...ArgTypes>
+  static InFlightDiagnostic diagnose(StringRef interfacePath,
+                                     SourceLoc diagnosticLoc,
+                                     SourceManager &SM,
+                                     DiagnosticEngine *Diags,
+                                     Diag<ArgTypes...> ID,
+                                     typename detail::PassArgument<ArgTypes>::type... Args) {
+    SourceLoc loc = diagnosticLoc;
+    if (diagnosticLoc.isInvalid()) {
+      // Diagnose this inside the interface file, if possible.
+      loc = SM.getLocFromExternalSource(interfacePath, 1, 1);
+    }
+    return Diags->diagnose(loc, ID, std::move(Args)...);
+  }
+
   std::error_code runInSubContext(StringRef moduleName,
                                   StringRef interfacePath,
                                   StringRef outputPath,

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -93,6 +93,10 @@ bool ArgsToFrontendOptionsConverter::convert(
   if (Args.hasArg(OPT_track_system_dependencies)) {
     Opts.IntermoduleDependencyTracking =
         IntermoduleDepTrackingMode::IncludeSystem;
+  } else if (Args.hasArg(OPT_explicit_interface_module_build)) {
+    // Always track at least the non-system dependencies for interface building.
+    Opts.IntermoduleDependencyTracking =
+        IntermoduleDepTrackingMode::ExcludeSystem;
   }
 
   if (const Arg *A = Args.getLastArg(OPT_bad_file_descriptor_retry_count)) {
@@ -624,7 +628,7 @@ bool ArgsToFrontendOptionsConverter::checkBuildFromInterfaceOnlyOptions()
   if (Opts.RequestedAction != FrontendOptions::ActionType::CompileModuleFromInterface &&
       Opts.ExplicitInterfaceBuild) {
     Diags.diagnose(SourceLoc(),
-                   diag::error_cannot_ignore_interface_options_in_mode);
+                   diag::error_cannot_explicit_interface_build_in_mode);
     return true;
   }
   return false;

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -181,32 +181,29 @@ bool ExplicitModuleInterfaceBuilder::collectDepsForSerialization(
 }
 
 std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
-    StringRef interfacePath, StringRef outputPath, bool ShouldSerializeDeps,
+    StringRef InterfacePath, StringRef OutputPath, bool ShouldSerializeDeps,
     std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
-    ArrayRef<std::string> compiledCandidates,
+    ArrayRef<std::string> CompiledCandidates,
     StringRef CompilerVersion) {
   auto Invocation = Instance.getInvocation();
   // Try building forwarding module first. If succeed, return.
   if (Instance.getASTContext()
           .getModuleInterfaceChecker()
-          ->tryEmitForwardingModule(Invocation.getModuleName(), interfacePath,
-                                    compiledCandidates, outputPath)) {
+          ->tryEmitForwardingModule(Invocation.getModuleName(), InterfacePath,
+                                    CompiledCandidates, OutputPath)) {
     return std::error_code();
   }
   FrontendOptions &FEOpts = Invocation.getFrontendOptions();
   bool isTypeChecking =
       (FEOpts.RequestedAction == FrontendOptions::ActionType::Typecheck);
   const auto &InputInfo = FEOpts.InputsAndOutputs.firstInput();
   StringRef InPath = InputInfo.getFileName();
-  const auto &OutputInfo =
-      InputInfo.getPrimarySpecificPaths().SupplementaryOutputs;
-  StringRef OutPath = OutputInfo.ModuleOutputPath;
 
   // Build the .swiftmodule; this is a _very_ abridged version of the logic
   // in performCompile in libFrontendTool, specialized, to just the one
   // module-serialization task we're trying to do here.
   LLVM_DEBUG(llvm::dbgs() << "Setting up instance to compile " << InPath
-                          << " to " << OutPath << "\n");
+                          << " to " << OutputPath << "\n");
 
   LLVM_DEBUG(llvm::dbgs() << "Performing sema\n");
   if (isTypeChecking && FEOpts.DowngradeInterfaceVerificationError) {
@@ -224,12 +221,12 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
           Instance.getASTContext());
 
       if (!isTypeChecking && CompilerVersion.str() != builtByCompiler) {
-        diagnose(&Instance.getDiags(), Instance.getSourceMgr(), interfacePath,
+        diagnose(&Instance.getDiags(), Instance.getSourceMgr(), InterfacePath,
                  diag::module_interface_build_failed_mismatching_compiler,
                  Invocation.getModuleName(), CompilerVersion,
                  builtByCompiler);
       } else {
-        diagnose(&Instance.getDiags(), Instance.getSourceMgr(), interfacePath,
+        diagnose(&Instance.getDiags(), Instance.getSourceMgr(), InterfacePath,
                  diag::module_interface_build_failed, isTypeChecking,
                  Invocation.getModuleName(),
                  CompilerVersion.str() == builtByCompiler, CompilerVersion.str(),
@@ -259,7 +256,7 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
   // Setup the callbacks for serialization, which can occur during the
   // optimization pipeline.
   SerializationOptions SerializationOpts;
-  std::string OutPathStr = OutPath.str();
+  std::string OutPathStr = OutputPath.str();
   SerializationOpts.OutputPath = OutPathStr.c_str();
   SerializationOpts.ModuleLinkName = FEOpts.ModuleLinkName;
   SerializationOpts.AutolinkForceLoad =
@@ -274,8 +271,8 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
   SerializationOpts.SDKName = Instance.getASTContext().LangOpts.SDKName;
   SerializationOpts.ABIDescriptorPath = ABIDescriptorPath.str();
   SmallVector<FileDependency, 16> Deps;
-  bool serializeHashes = FEOpts.SerializeModuleInterfaceDependencyHashes;
-  if (collectDepsForSerialization(Deps, interfacePath, serializeHashes)) {
+  bool SerializeHashes = FEOpts.SerializeModuleInterfaceDependencyHashes;
+  if (collectDepsForSerialization(Deps, InterfacePath, SerializeHashes)) {
     return std::make_error_code(std::errc::not_supported);
   }
   if (ShouldSerializeDeps)

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1259,13 +1259,83 @@ bool ModuleInterfaceLoader::buildSwiftModuleFromSwiftInterface(
                                         SearchPathOpts.CandidateCompiledModules);
 }
 
+static bool readSwiftInterfaceVersionAndArgs(
+    SourceManager &SM, DiagnosticEngine &Diags, llvm::StringSaver &ArgSaver,
+    SmallVectorImpl<const char *> &SubArgs, std::string &CompilerVersion,
+    StringRef interfacePath, SourceLoc diagnosticLoc) {
+  llvm::vfs::FileSystem &fs = *SM.getFileSystem();
+  auto FileOrError = swift::vfs::getFileOrSTDIN(fs, interfacePath);
+  if (!FileOrError) {
+    // Don't use this->diagnose() because it'll just try to re-open
+    // interfacePath.
+    Diags.diagnose(diagnosticLoc, diag::error_open_input_file, interfacePath,
+                   FileOrError.getError().message());
+    return true;
+  }
+  auto SB = FileOrError.get()->getBuffer();
+  auto VersRe = getSwiftInterfaceFormatVersionRegex();
+  auto CompRe = getSwiftInterfaceCompilerVersionRegex();
+  SmallVector<StringRef, 1> VersMatches, CompMatches;
+
+  if (!VersRe.match(SB, &VersMatches)) {
+    InterfaceSubContextDelegateImpl::diagnose(
+        interfacePath, diagnosticLoc, SM, &Diags,
+        diag::error_extracting_version_from_module_interface);
+    return true;
+  }
+
+  if (extractCompilerFlagsFromInterface(interfacePath, SB, ArgSaver, SubArgs)) {
+    InterfaceSubContextDelegateImpl::diagnose(
+        interfacePath, diagnosticLoc, SM, &Diags,
+        diag::error_extracting_version_from_module_interface);
+    return true;
+  }
+
+  assert(VersMatches.size() == 2);
+  // FIXME We should diagnose this at a location that makes sense:
+  auto Vers = swift::version::Version(VersMatches[1], SourceLoc(), &Diags);
+
+  if (CompRe.match(SB, &CompMatches)) {
+    assert(CompMatches.size() == 2);
+    CompilerVersion = ArgSaver.save(CompMatches[1]).str();
+  } else {
+    // Don't diagnose; handwritten module interfaces don't include this field.
+    CompilerVersion = "(unspecified, file possibly handwritten)";
+  }
+
+  // For now: we support anything with the same "major version" and assume
+  // minor versions might be interesting for debugging, or special-casing a
+  // compatible field variant.
+  if (Vers.asMajorVersion() != InterfaceFormatVersion.asMajorVersion()) {
+    InterfaceSubContextDelegateImpl::diagnose(
+        interfacePath, diagnosticLoc, SM, &Diags,
+        diag::unsupported_version_of_module_interface, interfacePath, Vers);
+    return true;
+  }
+  return false;
+}
+
 bool ModuleInterfaceLoader::buildExplicitSwiftModuleFromSwiftInterface(
     CompilerInstance &Instance, const StringRef moduleCachePath,
     const StringRef backupInterfaceDir, const StringRef prebuiltCachePath,
     const StringRef ABIDescriptorPath, StringRef interfacePath,
     StringRef outputPath, bool ShouldSerializeDeps,
-    ArrayRef<std::string> CompiledCandidates, StringRef CompilerVersion,
+    ArrayRef<std::string> CompiledCandidates,
     DependencyTracker *tracker) {
+  
+  // Read out the compiler version.
+  llvm::BumpPtrAllocator alloc;
+  llvm::StringSaver ArgSaver(alloc);
+  std::string CompilerVersion;
+  SmallVector<const char *, 64> InterfaceArgs;
+  readSwiftInterfaceVersionAndArgs(Instance.getSourceMgr(),
+                                   Instance.getDiags(),
+                                   ArgSaver,
+                                   InterfaceArgs,
+                                   CompilerVersion,
+                                   interfacePath,
+                                   SourceLoc());
+  
   auto Builder = ExplicitModuleInterfaceBuilder(
       Instance, moduleCachePath, backupInterfaceDir, prebuiltCachePath,
       ABIDescriptorPath);
@@ -1381,53 +1451,10 @@ bool InterfaceSubContextDelegateImpl::extractSwiftInterfaceVersionAndArgs(
     std::string &CompilerVersion,
     StringRef interfacePath,
     SourceLoc diagnosticLoc) {
-  llvm::vfs::FileSystem &fs = *SM.getFileSystem();
-  auto FileOrError = swift::vfs::getFileOrSTDIN(fs, interfacePath);
-  if (!FileOrError) {
-    // Don't use this->diagnose() because it'll just try to re-open
-    // interfacePath.
-    Diags->diagnose(diagnosticLoc, diag::error_open_input_file,
-                    interfacePath, FileOrError.getError().message());
-    return true;
-  }
-  auto SB = FileOrError.get()->getBuffer();
-  auto VersRe = getSwiftInterfaceFormatVersionRegex();
-  auto CompRe = getSwiftInterfaceCompilerVersionRegex();
-  SmallVector<StringRef, 1> VersMatches, CompMatches;
-
-  if (!VersRe.match(SB, &VersMatches)) {
-    diagnose(interfacePath, diagnosticLoc,
-             diag::error_extracting_version_from_module_interface);
-    return true;
-  }
-  
-  if (extractCompilerFlagsFromInterface(interfacePath, SB, ArgSaver, SubArgs)) {
-    diagnose(interfacePath, diagnosticLoc,
-             diag::error_extracting_version_from_module_interface);
+  if (readSwiftInterfaceVersionAndArgs(SM, *Diags, ArgSaver, SubArgs,
+                                       CompilerVersion, interfacePath,
+                                       diagnosticLoc))
     return true;
-  }
-  
-  assert(VersMatches.size() == 2);
-  // FIXME We should diagnose this at a location that makes sense:
-  auto Vers = swift::version::Version(VersMatches[1], SourceLoc(), Diags);
-
-  if (CompRe.match(SB, &CompMatches)) {
-    assert(CompMatches.size() == 2);
-    CompilerVersion = ArgSaver.save(CompMatches[1]).str();
-  }
-  else {
-    // Don't diagnose; handwritten module interfaces don't include this field.
-    CompilerVersion = "(unspecified, file possibly handwritten)";
-  }
-
-  // For now: we support anything with the same "major version" and assume
-  // minor versions might be interesting for debugging, or special-casing a
-  // compatible field variant.
-  if (Vers.asMajorVersion() != InterfaceFormatVersion.asMajorVersion()) {
-    diagnose(interfacePath, diagnosticLoc,
-             diag::unsupported_version_of_module_interface, interfacePath, Vers);
-    return true;
-  }
 
   SmallString<32> ExpectedModuleName = subInvocation.getModuleName();
   if (subInvocation.parseArgs(SubArgs, *Diags)) {