[5.1] -build-module-from-parseable-interface: Don't make an extra ASTContext

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

@@ -599,7 +599,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: