Break Driver's dep on Frontend: make createCompilerInvocation uglier

But not even that much uglier; at all three call sites this will save
an allocation, and for the most important one (SourceKit) we can now
avoid creating a temporary CompilerInvocation just to copy into a
longer-lived one.

With this change, Driver no longer depends on Frontend, which means...
well, slightly faster builds of the compiler itself, but not much
else.

Author: jrose-apple

include/swift/Driver/FrontendUtil.h

@@ -14,31 +14,33 @@
 #define SWIFT_DRIVER_FRONTENDUTIL_H
 
 #include "swift/Basic/LLVM.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include <memory>
 
 namespace swift {
 
-class CompilerInvocation;
 class DiagnosticEngine;
 
 namespace driver {
 
-/// \brief Creates a CompilerInvocation from the given driver arguments.
+/// Generates the list of arguments that would be passed to the compiler
+/// frontend from the given driver arguments.
 ///
-/// \param ArgList The driver arguments for which a CompilerInvocation
-/// should be created.
-/// \param Diags The DiagnosticEngine which should be used for parsing arguments
+/// \param ArgList The driver arguments (i.e. normal arguments for \c swiftc).
+/// \param Diags The DiagnosticEngine used to report any errors parsing the
+/// arguments.
+/// \param Action Called with the list of frontend arguments if there were no
+/// errors in processing \p ArgList. This is a callback rather than a return
+/// value to avoid copying the arguments more than necessary.
 ///
-/// \returns A fully-formed CompilerInvocation, or nullptr if one couldn't be
-/// created.
+/// \returns True on error, or if \p Action returns true.
 ///
-/// \note This function is not intended to create CompilerInvocation instances
-/// which are suitable for use in REPL or immediate modes, since it will have
-/// the effect of overriding the frontend's requested action to
-/// FrontendOptions::ActionType::Parse.
-std::unique_ptr<CompilerInvocation> createCompilerInvocation(
-    ArrayRef<const char *> ArgList, DiagnosticEngine &Diags);
+/// \note This function is not intended to create invocations which are
+/// suitable for use in REPL or immediate modes.
+bool getSingleFrontendInvocationFromDriverArguments(
+    ArrayRef<const char *> ArgList, DiagnosticEngine &Diags,
+    llvm::function_ref<bool(ArrayRef<const char *> FrontendArgs)> Action);
 
 } // end namespace driver
 } // end namespace swift

lib/Driver/CMakeLists.txt

@@ -19,7 +19,7 @@ set(swiftDriver_targetDefines)
 add_swift_library(swiftDriver STATIC
   ${swiftDriver_sources}
   DEPENDS SwiftOptions
-  LINK_LIBRARIES swiftAST swiftBasic swiftFrontend swiftOption)
+  LINK_LIBRARIES swiftAST swiftBasic swiftOption)
 
 # Generate the static-stdlib-args.lnk file used by -static-stdlib option
 # for 'GenericUnix' (eg linux)

lib/Driver/FrontendUtil.cpp

@@ -18,14 +18,14 @@
 #include "swift/Driver/Driver.h"
 #include "swift/Driver/Job.h"
 #include "swift/Driver/ToolChain.h"
-#include "swift/Frontend/Frontend.h"
+#include "llvm/Option/ArgList.h"
 
 using namespace swift;
 using namespace swift::driver;
 
-std::unique_ptr<CompilerInvocation>
-swift::driver::createCompilerInvocation(ArrayRef<const char *> Argv,
-                                        DiagnosticEngine &Diags) {
+bool swift::driver::getSingleFrontendInvocationFromDriverArguments(
+    ArrayRef<const char *> Argv, DiagnosticEngine &Diags,
+    llvm::function_ref<bool(ArrayRef<const char *> FrontendArgs)> Action) {
   SmallVector<const char *, 16> Args;
   Args.push_back("<swiftc>"); // FIXME: Remove dummy argument.
   Args.insert(Args.end(), Argv.begin(), Argv.end());
@@ -55,16 +55,16 @@ swift::driver::createCompilerInvocation(ArrayRef<const char *> Argv,
   std::unique_ptr<llvm::opt::InputArgList> ArgList =
     TheDriver.parseArgStrings(ArrayRef<const char *>(Args).slice(1));
   if (Diags.hadAnyError())
-    return nullptr;
+    return true;
 
   std::unique_ptr<ToolChain> TC = TheDriver.buildToolChain(*ArgList);
   if (Diags.hadAnyError())
-    return nullptr;
+    return true;
 
   std::unique_ptr<Compilation> C =
       TheDriver.buildCompilation(*TC, std::move(ArgList));
   if (!C || C->getJobs().empty())
-    return nullptr; // Don't emit an error; one should already have been emitted
+    return true; // Don't emit an error; one should already have been emitted
 
   SmallPtrSet<const Job *, 4> CompileCommands;
   for (const Job *Cmd : C->getJobs())
@@ -74,22 +74,15 @@ swift::driver::createCompilerInvocation(ArrayRef<const char *> Argv,
   if (CompileCommands.size() != 1) {
     // TODO: include Jobs in the diagnostic.
     Diags.diagnose(SourceLoc(), diag::error_expected_one_frontend_job);
-    return nullptr;
+    return true;
   }
 
   const Job *Cmd = *CompileCommands.begin();
   if (StringRef("-frontend") != Cmd->getArguments().front()) {
     Diags.diagnose(SourceLoc(), diag::error_expected_frontend_command);
-    return nullptr;
+    return true;
   }
 
-  std::unique_ptr<CompilerInvocation> Invocation(new CompilerInvocation());
   const llvm::opt::ArgStringList &BaseFrontendArgs = Cmd->getArguments();
-  ArrayRef<const char *> FrontendArgs =
-      llvm::makeArrayRef(BaseFrontendArgs.data() + 1,
-                         BaseFrontendArgs.data() + BaseFrontendArgs.size());
-  if (Invocation->parseArgs(FrontendArgs, Diags))
-    return nullptr; // Don't emit an error; one should already have been emitted
-
-  return Invocation;
+  return Action(llvm::makeArrayRef(BaseFrontendArgs).drop_front());
 }

tools/SourceKit/lib/SwiftLang/SwiftASTManager.cpp

@@ -434,9 +434,12 @@ bool SwiftASTManager::initCompilerInvocation(CompilerInvocation &Invocation,
   Args.push_back("-resource-dir");
   Args.push_back(Impl.RuntimeResourcePath.c_str());
 
-  if (auto driverInvocation = driver::createCompilerInvocation(Args, Diags)) {
-    Invocation = *driverInvocation;
-  } else {
+  bool HadError = driver::getSingleFrontendInvocationFromDriverArguments(
+      Args, Diags, [&](ArrayRef<const char *> FrontendArgs) {
+    return Invocation.parseArgs(FrontendArgs, Diags);
+  });
+
+  if (HadError) {
     // FIXME: Get the actual diagnostic.
     Error = "error when parsing the compiler arguments";
     return true;

tools/swift-ide-test/ModuleAPIDiff.cpp

@@ -907,27 +907,30 @@ int swift::doGenerateModuleAPIDescription(StringRef MainExecutablePath,
   DiagnosticEngine Diags(SM);
   Diags.addConsumer(PDC);
 
-  std::unique_ptr<CompilerInvocation> Invocation =
-      driver::createCompilerInvocation(CStringArgs, Diags);
+  CompilerInvocation Invocation;
+  bool HadError = driver::getSingleFrontendInvocationFromDriverArguments(
+      CStringArgs, Diags, [&](ArrayRef<const char *> FrontendArgs) {
+    return Invocation.parseArgs(FrontendArgs, Diags);
+  });
 
-  if (!Invocation) {
+  if (HadError) {
     llvm::errs() << "error: unable to create a CompilerInvocation\n";
     return 1;
   }
 
-  Invocation->setMainExecutablePath(MainExecutablePath);
+  Invocation.setMainExecutablePath(MainExecutablePath);
 
   CompilerInstance CI;
   CI.addDiagnosticConsumer(&PDC);
-  if (CI.setup(*Invocation))
+  if (CI.setup(Invocation))
     return 1;
   CI.performSema();
 
   PrintOptions Options = PrintOptions::printEverything();
 
   ModuleDecl *M = CI.getMainModule();
-  M->getMainSourceFile(Invocation->getSourceFileKind()).print(llvm::outs(),
-                                                        Options);
+  M->getMainSourceFile(Invocation.getSourceFileKind()).print(llvm::outs(),
+                                                             Options);
 
   auto SMAModel = createSMAModel(M);
   llvm::yaml::Output YOut(llvm::outs());

tools/swift-ide-test/swift-ide-test.cpp

@@ -2909,10 +2909,13 @@ static int doTestCreateCompilerInvocation(ArrayRef<const char *> Args) {
   DiagnosticEngine Diags(SM);
   Diags.addConsumer(PDC);
 
-  std::unique_ptr<CompilerInvocation> CI =
-    driver::createCompilerInvocation(Args, Diags);
+  CompilerInvocation CI;
+  bool HadError = driver::getSingleFrontendInvocationFromDriverArguments(
+      Args, Diags, [&](ArrayRef<const char *> FrontendArgs) {
+    return CI.parseArgs(FrontendArgs, Diags);
+  });
 
-  if (!CI) {
+  if (HadError) {
     llvm::errs() << "error: unable to create a CompilerInvocation\n";
     return 1;
   }