-build-module-from-parseable-interface: Don't make an extra ASTContext (#25185)

This mode is supposed to get all its configuration information from
the switftinterface being read in, but that means that the ASTContext
and ClangImporter that get created by default may not be a sensible
configuration (for example, a mismatched target and SDK, which Clang
emits a warning about). Avoid this by just not creating the ASTContext
if it's already been determined that the frontend is building a module
from a parseable interface.

Author: jrose-apple

include/swift/Frontend/Frontend.h

@@ -535,6 +535,7 @@ class CompilerInstance {
   }
 
   bool setUpInputs();
+  bool setUpASTContextIfNeeded();
   Optional<unsigned> setUpCodeCompletionBuffer();
 
   /// Set up all state in the CompilerInstance to process the given input file.

include/swift/Frontend/ParseableInterfaceModuleLoader.h

@@ -116,6 +116,9 @@ namespace unittest {
 
 namespace swift {
 
+  class LangOptions;
+  class SearchPathOptions;
+
 /// A ModuleLoader that runs a subordinate \c CompilerInvocation and
 /// \c CompilerInstance to convert .swiftinterface files to .swiftmodule
 /// files on the fly, caching the resulting .swiftmodules in the module cache
@@ -162,10 +165,11 @@ class ParseableInterfaceModuleLoader : public SerializedModuleLoaderBase {
   /// Unconditionally build \p InPath (a swiftinterface file) to \p OutPath (as
   /// a swiftmodule file).
   ///
-  /// A simplified version of the core logic in #openModuleFiles, mostly for
-  /// testing purposes.
+  /// A simplified version of the core logic in #openModuleFiles.
   static bool buildSwiftModuleFromSwiftInterface(
-    ASTContext &Ctx, StringRef CacheDir, StringRef PrebuiltCacheDir,
+    SourceManager &SourceMgr, DiagnosticEngine &Diags,
+    const SearchPathOptions &SearchPathOpts, const LangOptions &LangOpts,
+    StringRef CacheDir, StringRef PrebuiltCacheDir,
     StringRef ModuleName, StringRef InPath, StringRef OutPath,
     bool SerializeDependencyHashes, bool TrackSystemDependencies,
     bool RemarkOnRebuildFromInterface);

lib/Frontend/Frontend.cpp

@@ -175,6 +175,26 @@ void CompilerInstance::recordPrimarySourceFile(SourceFile *SF) {
     recordPrimaryInputBuffer(SF->getBufferID().getValue());
 }
 
+bool CompilerInstance::setUpASTContextIfNeeded() {
+  if (Invocation.getFrontendOptions().RequestedAction ==
+      FrontendOptions::ActionType::CompileModuleFromInterface) {
+    // Compiling a module interface from source uses its own CompilerInstance
+    // with options read from the input file. Don't bother setting up an
+    // ASTContext at this level.
+    return false;
+  }
+
+  Context.reset(ASTContext::get(Invocation.getLangOptions(),
+                                Invocation.getSearchPathOptions(), SourceMgr,
+                                Diagnostics));
+  registerTypeCheckerRequestFunctions(Context->evaluator);
+
+  if (setUpModuleLoaders())
+    return true;
+
+  return false;
+}
+
 bool CompilerInstance::setup(const CompilerInvocation &Invok) {
   Invocation = Invok;
 
@@ -196,20 +216,18 @@ bool CompilerInstance::setup(const CompilerInvocation &Invok) {
     Invocation.getLangOptions().AttachCommentsToDecls = true;
   }
 
-  Context.reset(ASTContext::get(Invocation.getLangOptions(),
-                                Invocation.getSearchPathOptions(), SourceMgr,
-                                Diagnostics));
-  registerTypeCheckerRequestFunctions(Context->evaluator);
-
-  if (setUpModuleLoaders())
-    return true;
-
   assert(Lexer::isIdentifier(Invocation.getModuleName()));
 
   if (isInSILMode())
     Invocation.getLangOptions().EnableAccessControl = false;
 
-  return setUpInputs();
+  if (setUpInputs())
+    return true;
+
+  if (setUpASTContextIfNeeded())
+    return true;
+
+  return false;
 }
 
 static bool loadAndValidateVFSOverlay(

lib/Frontend/ParseableInterfaceModuleLoader.cpp

@@ -280,7 +280,6 @@ static Optional<StringRef> getRelativeDepPath(StringRef DepPath,
 /// output path.
 /// \note Needs to be in the swift namespace so CompilerInvocation can see it.
 class swift::ParseableInterfaceBuilder {
-  ASTContext &ctx;
   llvm::vfs::FileSystem &fs;
   DiagnosticEngine &diags;
   const StringRef interfacePath;
@@ -307,10 +306,9 @@ class swift::ParseableInterfaceBuilder {
       .setMainAndSupplementaryOutputs({MainOut}, {SOPs});
   }
 
-  void configureSubInvocation() {
-    auto &SearchPathOpts = ctx.SearchPathOpts;
-    auto &LangOpts = ctx.LangOpts;
-
+  void configureSubInvocation(const SearchPathOptions &SearchPathOpts,
+                              const LangOptions &LangOpts,
+                              ClangModuleLoader *ClangLoader) {
     // Start with a SubInvocation that copies various state from our
     // invoking ASTContext.
     subInvocation.setImportSearchPaths(SearchPathOpts.ImportSearchPaths);
@@ -329,7 +327,7 @@ class swift::ParseableInterfaceBuilder {
     // Respect the detailed-record preprocessor setting of the parent context.
     // This, and the "raw" clang module format it implicitly enables, are
     // required by sourcekitd.
-    if (auto *ClangLoader = ctx.getClangModuleLoader()) {
+    if (ClangLoader) {
       auto &Opts = ClangLoader->getClangInstance().getPreprocessorOpts();
       if (Opts.DetailedRecord) {
         subInvocation.getClangImporterOptions().DetailedPreprocessingRecord = true;
@@ -472,7 +470,10 @@ class swift::ParseableInterfaceBuilder {
   }
 
 public:
-  ParseableInterfaceBuilder(ASTContext &ctx,
+  ParseableInterfaceBuilder(SourceManager &sourceMgr, DiagnosticEngine &diags,
+                            const SearchPathOptions &searchPathOpts,
+                            const LangOptions &langOpts,
+                            ClangModuleLoader *clangImporter,
                             StringRef interfacePath,
                             StringRef moduleName,
                             StringRef moduleCachePath,
@@ -482,14 +483,14 @@ class swift::ParseableInterfaceBuilder {
                             bool remarkOnRebuildFromInterface = false,
                             SourceLoc diagnosticLoc = SourceLoc(),
                             DependencyTracker *tracker = nullptr)
-  : ctx(ctx), fs(*ctx.SourceMgr.getFileSystem()), diags(ctx.Diags),
-  interfacePath(interfacePath), moduleName(moduleName),
-  moduleCachePath(moduleCachePath), prebuiltCachePath(prebuiltCachePath),
-  serializeDependencyHashes(serializeDependencyHashes),
-  trackSystemDependencies(trackSystemDependencies),
-  remarkOnRebuildFromInterface(remarkOnRebuildFromInterface),
-  diagnosticLoc(diagnosticLoc), dependencyTracker(tracker) {
-    configureSubInvocation();
+    : fs(*sourceMgr.getFileSystem()), diags(diags),
+      interfacePath(interfacePath), moduleName(moduleName),
+      moduleCachePath(moduleCachePath), prebuiltCachePath(prebuiltCachePath),
+      serializeDependencyHashes(serializeDependencyHashes),
+      trackSystemDependencies(trackSystemDependencies),
+      remarkOnRebuildFromInterface(remarkOnRebuildFromInterface),
+      diagnosticLoc(diagnosticLoc), dependencyTracker(tracker) {
+    configureSubInvocation(searchPathOpts, langOpts, clangImporter);
   }
 
   const CompilerInvocation &getSubInvocation() const {
@@ -1236,9 +1237,11 @@ class ParseableInterfaceModuleLoaderImpl {
     // Set up a builder if we need to build the module. It'll also set up
     // the subinvocation we'll need to use to compute the cache paths.
     ParseableInterfaceBuilder builder(
-      ctx, interfacePath, moduleName, cacheDir, prebuiltCacheDir,
-      /*serializeDependencyHashes*/false, trackSystemDependencies,
-      remarkOnRebuildFromInterface, diagnosticLoc, dependencyTracker);
+      ctx.SourceMgr, ctx.Diags, ctx.SearchPathOpts, ctx.LangOpts,
+      ctx.getClangModuleLoader(), interfacePath, moduleName, cacheDir,
+      prebuiltCacheDir, /*serializeDependencyHashes*/false,
+      trackSystemDependencies, remarkOnRebuildFromInterface, diagnosticLoc,
+      dependencyTracker);
     auto &subInvocation = builder.getSubInvocation();
 
     // Compute the output path if we're loading or emitting a cached module.
@@ -1373,12 +1376,15 @@ std::error_code ParseableInterfaceModuleLoader::findModuleFilesInDirectory(
 
 
 bool ParseableInterfaceModuleLoader::buildSwiftModuleFromSwiftInterface(
-  ASTContext &Ctx, StringRef CacheDir, StringRef PrebuiltCacheDir,
-  StringRef ModuleName, StringRef InPath, StringRef OutPath,
-  bool SerializeDependencyHashes, bool TrackSystemDependencies,
-  bool RemarkOnRebuildFromInterface) {
-  ParseableInterfaceBuilder builder(Ctx, InPath, ModuleName,
-                                    CacheDir, PrebuiltCacheDir,
+    SourceManager &SourceMgr, DiagnosticEngine &Diags,
+    const SearchPathOptions &SearchPathOpts, const LangOptions &LangOpts,
+    StringRef CacheDir, StringRef PrebuiltCacheDir,
+    StringRef ModuleName, StringRef InPath, StringRef OutPath,
+    bool SerializeDependencyHashes, bool TrackSystemDependencies,
+    bool RemarkOnRebuildFromInterface) {
+  ParseableInterfaceBuilder builder(SourceMgr, Diags, SearchPathOpts, LangOpts,
+                                    /*clangImporter*/nullptr, InPath,
+                                    ModuleName, CacheDir, PrebuiltCacheDir,
                                     SerializeDependencyHashes,
                                     TrackSystemDependencies,
                                     RemarkOnRebuildFromInterface);

lib/FrontendTool/FrontendTool.cpp

@@ -597,7 +597,9 @@ static bool buildModuleFromParseableInterface(CompilerInvocation &Invocation,
   StringRef InputPath = FEOpts.InputsAndOutputs.getFilenameOfFirstInput();
   StringRef PrebuiltCachePath = FEOpts.PrebuiltModuleCachePath;
   return ParseableInterfaceModuleLoader::buildSwiftModuleFromSwiftInterface(
-      Instance.getASTContext(), Invocation.getClangModuleCachePath(),
+      Instance.getSourceMgr(), Instance.getDiags(),
+      Invocation.getSearchPathOptions(), Invocation.getLangOptions(),
+      Invocation.getClangModuleCachePath(),
       PrebuiltCachePath, Invocation.getModuleName(), InputPath,
       Invocation.getOutputFilename(),
       FEOpts.SerializeModuleInterfaceDependencyHashes,

test/ParseableInterface/NoWrongSDKWarning.swiftinterface

@@ -0,0 +1,13 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -target x86_64-apple-macos10.9
+
+// Deliberately pass the wrong target at the command line and see what happens.
+// RUN: %empty-directory(%t)
+// RUN: %swift -sdk %sdk -target arm64-apple-ios10 -build-module-from-parseable-interface %s -o %t/NoWrongSDKWarning.swiftmodule 2>&1 | %FileCheck -allow-empty %s
+
+// REQUIRES: OS=macosx
+
+public func empty()
+
+// CHECK-NOT: warning:
+// CHECK-NOT: error: