Preload standard library in ModuleInterfaceBuilder

include/swift/Basic/SourceManager.h

@@ -290,6 +290,11 @@ class SourceManager {
   bool isLocInVirtualFile(SourceLoc Loc) const {
     return getVirtualFile(Loc) != nullptr;
   }
+
+  /// Return a SourceLoc in \c this corresponding to \p otherLoc, which must be
+  /// owned by \p otherManager. Returns an invalid SourceLoc if it cannot be
+  /// translated.
+  SourceLoc getLocForForeignLoc(SourceLoc otherLoc, SourceManager &otherMgr);
 };
 
 } // end namespace swift

lib/Basic/SourceLoc.cpp

@@ -395,3 +395,27 @@ SourceManager::getLocFromExternalSource(StringRef Path, unsigned Line,
     return SourceLoc();
   return getLocForOffset(BufferId, *Offset);
 }
+
+SourceLoc
+SourceManager::getLocForForeignLoc(SourceLoc otherLoc,
+                                   SourceManager &otherMgr) {
+  if (&otherMgr == this || otherLoc.isInvalid())
+    return otherLoc;
+
+  assert(otherMgr.isOwning(otherLoc));
+
+  if (auto otherBufferID = otherMgr.findBufferContainingLocInternal(otherLoc)) {
+    auto offset = otherMgr.getLocOffsetInBuffer(otherLoc, *otherBufferID);
+
+    auto otherBufferName = otherMgr.getIdentifierForBuffer(*otherBufferID);
+    auto thisBufferID = getIDForBufferIdentifier(otherBufferName);
+    if (!thisBufferID) {
+      thisBufferID = addMemBufferCopy(
+              otherMgr.getEntireTextForBuffer(*otherBufferID), otherBufferName);
+    }
+
+    return getLocForOffset(*thisBufferID, offset);
+  }
+
+  return SourceLoc();
+}

lib/Frontend/DiagnosticVerifier.cpp

@@ -972,6 +972,22 @@ void DiagnosticVerifier::handleDiagnostic(SourceManager &SM,
     CapturedDiagnostics.emplace_back(message, StringRef(), Info.Kind, Info.Loc,
                                      0, 0, fixIts, eduNotes);
   }
+
+  // If this diagnostic came from a different SourceManager (as can happen
+  // while compiling a module interface), translate its SourceLocs to match the
+  // verifier's SourceManager.
+  if (&SM != &(this->SM)) {
+    auto &capturedDiag = CapturedDiagnostics.back();
+    auto &correctSM = this->SM;
+
+    capturedDiag.Loc = correctSM.getLocForForeignLoc(capturedDiag.Loc, SM);
+    for (auto &fixIt : capturedDiag.FixIts) {
+      auto newStart = correctSM.getLocForForeignLoc(fixIt.getRange().getStart(),
+                                                    SM);
+      fixIt.getRange() = CharSourceRange(newStart,
+                                         fixIt.getRange().getByteLength());
+    }
+  }
 }
 
 /// Once all diagnostics have been captured, perform verification.

lib/Frontend/Frontend.cpp

@@ -307,6 +307,7 @@ bool CompilerInstance::setupDiagnosticVerifierIfNeeded() {
         Diagnostics.diagnose(SourceLoc(), diag::error_open_input_file,
                              filename, result.getError().message());
         hadError |= true;
+        continue;
       }
 
       auto bufferID = SourceMgr.addNewSourceBuffer(std::move(result.get()));

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -187,6 +187,13 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     InputInfo.getPrimarySpecificPaths().SupplementaryOutputs;
     StringRef OutPath = OutputInfo.ModuleOutputPath;
 
+    // Bail out if we're going to use the standard library but can't load it. If
+    // we don't do this before we try to build the interface, we could end up
+    // trying to rebuild a broken standard library dozens of times due to
+    // multiple calls to `ASTContext::getStdlibModule()`.
+    if (SubInstance.loadStdlibIfNeeded())
+      return std::make_error_code(std::errc::not_supported);
+
     // 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.

test/ModuleInterface/BadStdlib.swiftinterface

@@ -0,0 +1,19 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -target x86_64-apple-macos10.9 -module-name BadStdlib
+
+// no-error@-3
+
+// Tests whether -compile-module-from-interface correctly stops early when the
+// standard library module interface is broken, rather than trying to limp along
+// without a standard library, which tends to cause ClangImporter crashes (among
+// other things.)
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend(mock-sdk: -sdk %/S/Inputs/BadStdlib.sdk -module-cache-path %/t/module-cache -resource-dir %/S/Inputs/BadStdlib.sdk) -compile-module-from-interface -o %/t/BadStdlib.swiftmodule %s -verify -verify-additional-file %/S/Inputs/BadStdlib.sdk/usr/lib/swift/Swift.swiftmodule/x86_64-apple-macos.swiftinterface
+
+import ClangMod
+
+public func useHasPointer(_: HasPointer)
+
+// FIXME: SR-14489
+// UNSUPPORTED: windows

test/ModuleInterface/Inputs/BadStdlib.sdk/usr/include/ClangMod.h

@@ -0,0 +1 @@
+typedef int * HasPointer;

test/ModuleInterface/Inputs/BadStdlib.sdk/usr/include/module.modulemap

@@ -0,0 +1,4 @@
+module HasPointer {
+  header "HasPointer.h"
+  export *
+}

test/ModuleInterface/Inputs/BadStdlib.sdk/usr/lib/swift/Swift.swiftmodule/x86_64-apple-macos.swiftinterface

@@ -0,0 +1,9 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -target x86_64-apple-macos10.9 -module-name Swift -parse-stdlib
+
+// If the test fails, this error will be emitted twice, not once.
+// expected-error@-4 {{failed to build module 'Swift' for importation due to the errors above}}
+
+public struct BadType {
+  public var property: UndeclaredType { get set } // expected-error {{cannot find type 'UndeclaredType' in scope}}
+}