[Frontend] Load standard libarary in CompilerInstance::setup

Instead of checking that the stdlib can be loaded in a variety of places, check it when setting up the compiler instance. This required a couple more checks to avoid loading the stdlib in cases where it’s not needed.

To be able to differentiate stdlib loading failures from other setup errors, make `CompilerInstance::setup` return an error message on failure via an inout parameter. Consume that error on the call side, replacing a previous, more generic error message, adding error handling where appropriate or ignoring the error message, depending on the context.

Author: ahoppen

include/swift/Frontend/Frontend.h

@@ -341,6 +341,9 @@ class CompilerInvocation {
     if (FrontendOpts.InputMode == FrontendOptions::ParseInputMode::SIL) {
       return ImplicitStdlibKind::None;
     }
+    if (FrontendOpts.InputsAndOutputs.shouldTreatAsLLVM()) {
+      return ImplicitStdlibKind::None;
+    }
     if (getParseStdlib()) {
       return ImplicitStdlibKind::Builtin;
     }
@@ -562,7 +565,7 @@ class CompilerInstance {
   }
 
   /// Returns true if there was an error during setup.
-  bool setup(const CompilerInvocation &Invocation);
+  bool setup(const CompilerInvocation &Invocation, std::string &Error);
 
   const CompilerInvocation &getInvocation() const { return Invocation; }
 

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -313,6 +313,9 @@ struct ModuleInterfaceLoaderOptions {
     case FrontendOptions::ActionType::TypecheckModuleFromInterface:
       requestedAction = FrontendOptions::ActionType::Typecheck;
       break;
+    case FrontendOptions::ActionType::ScanDependencies:
+      requestedAction = Opts.RequestedAction;
+      break;
     default:
       requestedAction = FrontendOptions::ActionType::EmitModuleOnly;
       break;

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -2247,8 +2247,9 @@ swift::ide::api::getSDKNodeRoot(SDKContext &SDKCtx,
   // The PrintDiags is only responsible compiler errors, we should remove the
   // consumer immediately after importing is done.
   SWIFT_DEFER { CI.getDiags().removeConsumer(PrintDiags); };
-  if (CI.setup(Invocation)) {
-    llvm::errs() << "Failed to setup the compiler instance\n";
+  std::string InstanceSetupError;
+  if (CI.setup(Invocation, InstanceSetupError)) {
+    llvm::errs() << InstanceSetupError << '\n';
     return nullptr;
   }
 

lib/DependencyScan/DependencyScanningTool.cpp

@@ -194,7 +194,10 @@ DependencyScanningTool::initCompilerInstanceForScan(
   }
 
   // Setup the instance
-  Instance->setup(Invocation);
+  std::string InstanceSetupError;
+  if (Instance->setup(Invocation, InstanceSetupError)) {
+    return std::make_error_code(std::errc::not_supported);
+  }
   (void)Instance->getMainModule();
 
   return Instance;

lib/DependencyScan/ScanDependencies.cpp

@@ -1093,7 +1093,8 @@ forEachBatchEntry(CompilerInstance &invocationInstance,
             SourceLoc(), diag::scanner_arguments_invalid, entry.arguments);
         return true;
       }
-      if (pInstance->setup(subInvok)) {
+      std::string InstanceSetupError;
+      if (pInstance->setup(subInvok, InstanceSetupError)) {
         invocationInstance.getDiags().diagnose(
             SourceLoc(), diag::scanner_arguments_invalid, entry.arguments);
         return true;

lib/DriverTool/swift_api_digester_main.cpp

@@ -1849,8 +1849,10 @@ static bool readBreakageAllowlist(SDKContext &Ctx, llvm::StringSet<> &lines,
   CompilerInstance instance;
   CompilerInvocation invok;
   invok.setModuleName("ForClangImporter");
-  if (instance.setup(invok))
+  std::string InstanceSetupError;
+  if (instance.setup(invok, InstanceSetupError)) {
     return 1;
+  }
   auto importer = ClangImporter::create(instance.getASTContext());
   SmallString<128> preprocessedFilePath;
   if (auto error = llvm::sys::fs::createTemporaryFile(

lib/DriverTool/swift_api_extract_main.cpp

@@ -197,8 +197,9 @@ class SwiftAPIExtractInvocation {
   }
 
   int extractAPI() {
-    if (Instance.setup(Invocation)) {
-      llvm::outs() << "Failed to setup compiler instance\n";
+    std::string InstanceSetupError;
+    if (Instance.setup(Invocation, InstanceSetupError)) {
+      llvm::outs() << InstanceSetupError << '\n';
       return 1;
     }
 

lib/DriverTool/swift_symbolgraph_extract_main.cpp

@@ -182,8 +182,9 @@ int swift_symbolgraph_extract_main(ArrayRef<const char *> Args,
             .Default(AccessLevel::Public);
   }
 
-  if (CI.setup(Invocation)) {
-    llvm::outs() << "Failed to setup compiler instance\n";
+  std::string InstanceSetupError;
+  if (CI.setup(Invocation, InstanceSetupError)) {
+    llvm::outs() << InstanceSetupError << '\n';
     return EXIT_FAILURE;
   }
 

lib/Frontend/Frontend.cpp

@@ -357,30 +357,49 @@ void CompilerInstance::setupDependencyTrackerIfNeeded() {
   DepTracker = std::make_unique<DependencyTracker>(*collectionMode);
 }
 
-bool CompilerInstance::setup(const CompilerInvocation &Invok) {
+bool CompilerInstance::setup(const CompilerInvocation &Invok,
+                             std::string &Error) {
   Invocation = Invok;
 
   setupDependencyTrackerIfNeeded();
 
   // If initializing the overlay file system fails there's no sense in
   // continuing because the compiler will read the wrong files.
-  if (setUpVirtualFileSystemOverlays())
+  if (setUpVirtualFileSystemOverlays()) {
+    Error = "Setting up virtual file system overlays failed";
     return true;
+  }
   setUpLLVMArguments();
   setUpDiagnosticOptions();
 
   assert(Lexer::isIdentifier(Invocation.getModuleName()));
 
-  if (setUpInputs())
+  if (setUpInputs()) {
+    Error = "Setting up inputs failed";
     return true;
+  }
 
-  if (setUpASTContextIfNeeded())
+  if (setUpASTContextIfNeeded()) {
+    Error = "Setting up ASTContext failed";
     return true;
+  }
 
   setupStatsReporter();
 
-  if (setupDiagnosticVerifierIfNeeded())
+  if (setupDiagnosticVerifierIfNeeded()) {
+    Error = "Setting up diagnostics verified failed";
     return true;
+  }
+
+  // If we expect an implicit stdlib import, load in the standard library. If we
+  // either fail to find it or encounter an error while loading it, bail early. Continuing will at best
+  // trigger a bunch of other errors due to the stdlib being missing, or at
+  // worst crash downstream as many call sites don't currently handle a missing
+  // stdlib.
+  if (loadStdlibIfNeeded()) {
+    Error = "Loading the standard library failed";
+    return true;
+  }
 
   return false;
 }
@@ -1101,6 +1120,10 @@ void CompilerInstance::performSema() {
 }
 
 bool CompilerInstance::loadStdlibIfNeeded() {
+  if (!FrontendOptions::doesActionRequireSwiftStandardLibrary(
+          Invocation.getFrontendOptions().RequestedAction)) {
+    return false;
+  }
   // If we aren't expecting an implicit stdlib import, there's nothing to do.
   if (getImplicitImportInfo().StdlibKind != ImplicitStdlibKind::Stdlib)
     return false;

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -218,13 +218,6 @@ 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.