Define doesActionRequireInputs

Author: CodaFi

include/swift/Frontend/FrontendOptions.h

@@ -301,6 +301,9 @@ class FrontendOptions {
   /// loaded before it is run.
   static bool doesActionRequireSwiftStandardLibrary(ActionType);
 
+  /// \return true if the given action requires input files to be provided.
+  static bool doesActionRequireInputs(ActionType action);
+
   /// Return a hash code of any components from these options that should
   /// contribute to a Swift Bridging PCH hash.
   llvm::hash_code getPCHHashComponents() const {

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -406,8 +406,7 @@ bool ArgsToFrontendOptionsConverter::setUpInputKindAndImmediateArgs() {
   if (Opts.InputsAndOutputs.verifyInputs(
           Diags, treatAsSIL,
           Opts.RequestedAction == FrontendOptions::ActionType::REPL,
-          (Opts.RequestedAction == FrontendOptions::ActionType::NoneAction ||
-           Opts.RequestedAction == FrontendOptions::ActionType::PrintVersion))){
+          !FrontendOptions::doesActionRequireInputs(Opts.RequestedAction))) {
     return true;
   }
   if (Opts.RequestedAction == FrontendOptions::ActionType::Immediate) {

lib/Frontend/FrontendOptions.cpp

@@ -130,6 +130,47 @@ bool FrontendOptions::doesActionRequireSwiftStandardLibrary(ActionType action) {
   llvm_unreachable("Unknown ActionType");
 }
 
+bool FrontendOptions::doesActionRequireInputs(ActionType action) {
+  switch (action) {
+  case ActionType::NoneAction:
+  case ActionType::PrintVersion:
+    return false;
+  case ActionType::REPL:
+  case ActionType::Parse:
+  case ActionType::DumpParse:
+  case ActionType::EmitSyntax:
+  case ActionType::DumpInterfaceHash:
+  case ActionType::EmitImportedModules:
+  case ActionType::ScanDependencies:
+  case ActionType::ScanClangDependencies:
+  case ActionType::EmitPCH:
+  case ActionType::EmitPCM:
+  case ActionType::DumpPCM:
+  case ActionType::CompileModuleFromInterface:
+  case ActionType::TypecheckModuleFromInterface:
+  case ActionType::ResolveImports:
+  case ActionType::Typecheck:
+  case ActionType::DumpAST:
+  case ActionType::PrintAST:
+  case ActionType::DumpScopeMaps:
+  case ActionType::DumpTypeRefinementContexts:
+  case ActionType::EmitSILGen:
+  case ActionType::EmitSIL:
+  case ActionType::EmitModuleOnly:
+  case ActionType::MergeModules:
+  case ActionType::EmitSIBGen:
+  case ActionType::EmitSIB:
+  case ActionType::Immediate:
+  case ActionType::EmitAssembly:
+  case ActionType::EmitIR:
+  case ActionType::EmitBC:
+  case ActionType::EmitObject:
+  case ActionType::DumpTypeInfo:
+    return true;
+  }
+  llvm_unreachable("Unknown ActionType");
+}
+
 void FrontendOptions::forAllOutputPaths(
     const InputFile &input, llvm::function_ref<void(StringRef)> fn) const {
   if (RequestedAction != FrontendOptions::ActionType::EmitModuleOnly &&

lib/FrontendTool/FrontendTool.cpp

@@ -1653,6 +1653,7 @@ static void performEndOfPipelineActions(CompilerInstance &Instance) {
   // it's -emit-imported-modules, which can load modules.
   auto action = opts.RequestedAction;
   if (FrontendOptions::shouldActionOnlyParse(action) &&
+      !ctx.getLoadedModules().empty() &&
       action != FrontendOptions::ActionType::EmitImportedModules) {
     assert(ctx.getNumLoadedModules() == 1 &&
            "Loaded a module during parse-only");
@@ -1689,9 +1690,15 @@ static void performEndOfPipelineActions(CompilerInstance &Instance) {
     }
   }
 
-  // Emit dependencies and index data.
+  // FIXME: This predicate matches the status quo, but there's no reason
+  // indexing cannot run for actions that do not require stdlib e.g. to better
+  // facilitate tests.
+  if (FrontendOptions::doesActionRequireSwiftStandardLibrary(action)) {
+    emitIndexData(Instance);
+  }
+
+  // Emit dependencies.
   emitReferenceDependenciesForAllPrimaryInputsIfNeeded(Instance);
-  emitIndexData(Instance);
   emitMakeDependenciesIfNeeded(Instance.getDiags(),
                                Instance.getDependencyTracker(), opts);
 
@@ -1791,13 +1798,16 @@ static bool performAction(CompilerInstance &Instance,
     return buildModuleFromInterface(Instance);
 
   // MARK: Actions that Dump
-  case FrontendOptions::ActionType::DumpParse: {
+  case FrontendOptions::ActionType::DumpParse:
+    return dumpAST(Instance);
+  case FrontendOptions::ActionType::DumpAST: {
+    // FIXME: -dump-ast expects to be able to write output even if type checking
+    // fails which does not cleanly fit the model \c withSemanticAnalysis is
+    // trying to impose. Once there is a request for the "semantic AST", this
+    // point is moot.
+    Instance.performSema();
     return dumpAST(Instance);
   }
-  case FrontendOptions::ActionType::DumpAST:
-    return withSemanticAnalysis(
-        Instance, observer,
-        [](CompilerInstance &Instance) { return dumpAST(Instance); });
   case FrontendOptions::ActionType::PrintAST:
     return withSemanticAnalysis(
         Instance, observer, [](CompilerInstance &Instance) {
@@ -1860,9 +1870,6 @@ static bool performAction(CompilerInstance &Instance,
         Instance, observer, [&](CompilerInstance &Instance) {
           assert(FrontendOptions::doesActionGenerateSIL(opts.RequestedAction) &&
                  "All actions not requiring SILGen must have been handled!");
-          if (Instance.getInvocation().getInputKind() == InputFileKind::LLVM)
-            return compileLLVMIR(Instance);
-
           return performCompileStepsPostSema(Instance, ReturnValue, observer);
         });
   }
@@ -1882,6 +1889,10 @@ static bool performCompile(CompilerInstance &Instance,
   const auto &opts = Invocation.getFrontendOptions();
   const FrontendOptions::ActionType Action = opts.RequestedAction;
 
+  // To compile LLVM IR, just pass it off unmodified.
+  if (Instance.getInvocation().getInputKind() == InputFileKind::LLVM)
+    return compileLLVMIR(Instance);
+
   // If we aren't in a parse-only context and 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 the compilation will at best
@@ -1909,7 +1920,8 @@ static bool performCompile(CompilerInstance &Instance,
 
   // We might have freed the ASTContext already, but in that case we would
   // have already performed these actions.
-  if (Instance.hasASTContext()) {
+  if (Instance.hasASTContext() &&
+      FrontendOptions::doesActionRequireInputs(Action)) {
     performEndOfPipelineActions(Instance);
     hadError |= Instance.getASTContext().hadError();
   }