[Frontend] Remove parsing option params from performParseOnly

Lift the `DisablePoundIfEvaluation` parsing option
into `LangOptions` to subsume the need for the
`EvaluateConditionals` parameter, and sink the
computation of `CanDelayBodies` down into
`createSourceFileForMainModule`.

Author: hamishknight

include/swift/AST/SourceFile.h

@@ -105,7 +105,7 @@ class SourceFile final : public FileUnit {
     /// decl.
     ///
     /// FIXME: When condition evaluation moves to a later phase, remove this
-    /// and adjust the client call 'performParseOnly'.
+    /// and the associated language option.
     DisablePoundIfEvaluation = 1 << 1,
 
     /// Whether to build a syntax tree.

include/swift/Basic/LangOptions.h

@@ -335,6 +335,10 @@ namespace swift {
     /// Whether to verify the parsed syntax tree and emit related diagnostics.
     bool VerifySyntaxTree = false;
 
+    /// Whether to disable the evaluation of '#if' decls, such that the bodies
+    /// of active clauses aren't hoisted into the enclosing scope.
+    bool DisablePoundIfEvaluation = false;
+
     /// Instead of hashing tokens inside of NominalType and ExtensionBodies into
     /// the interface hash, hash them into per-iterable-decl-context
     /// fingerprints. Fine-grained dependency types won't dirty every provides

include/swift/Frontend/Frontend.h

@@ -616,8 +616,7 @@ class CompilerInstance {
   void performSema();
 
   /// Parses the input file but does no type-checking or module imports.
-  void performParseOnly(bool EvaluateConditionals = false,
-                        bool CanDelayBodies = true);
+  void performParseOnly();
 
   /// Parses and performs import resolution on all input files.
   ///
@@ -633,8 +632,7 @@ class CompilerInstance {
 private:
   SourceFile *
   createSourceFileForMainModule(SourceFileKind FileKind,
-                                Optional<unsigned> BufferID,
-                                SourceFile::ParsingOptions options = {});
+                                Optional<unsigned> BufferID);
 
 public:
   void freeASTContext();
@@ -647,8 +645,7 @@ class CompilerInstance {
   /// Retrieve a description of which modules should be implicitly imported.
   ImplicitImportInfo getImplicitImportInfo() const;
 
-  void performSemaUpTo(SourceFile::ASTStage_t LimitStage,
-                       SourceFile::ParsingOptions POpts = {});
+  void performSemaUpTo(SourceFile::ASTStage_t LimitStage);
 
   /// Return true if had load error
   bool loadPartialModulesAndImplicitImports();

lib/AST/Module.cpp

@@ -2233,6 +2233,8 @@ SourceFile::SourceFile(ModuleDecl &M, SourceFileKind K,
 SourceFile::ParsingOptions
 SourceFile::getDefaultParsingOptions(const LangOptions &langOpts) {
   ParsingOptions opts;
+  if (langOpts.DisablePoundIfEvaluation)
+    opts |= ParsingFlags::DisablePoundIfEvaluation;
   if (langOpts.BuildSyntaxTree)
     opts |= ParsingFlags::BuildSyntaxTree;
   if (langOpts.CollectParsedToken)

lib/Frontend/Frontend.cpp

@@ -729,20 +729,14 @@ void CompilerInstance::setMainModule(ModuleDecl *newMod) {
   Context->LoadedModules[newMod->getName()] = newMod;
 }
 
-void CompilerInstance::performParseOnly(bool EvaluateConditionals,
-                                        bool CanDelayBodies) {
+void CompilerInstance::performParseOnly() {
   const InputFileKind Kind = Invocation.getInputKind();
   assert((Kind == InputFileKind::Swift || Kind == InputFileKind::SwiftLibrary ||
           Kind == InputFileKind::SwiftModuleInterface) &&
          "only supports parsing .swift files");
   (void)Kind;
 
-  SourceFile::ParsingOptions parsingOpts;
-  if (!EvaluateConditionals)
-    parsingOpts |= SourceFile::ParsingFlags::DisablePoundIfEvaluation;
-  if (!CanDelayBodies)
-    parsingOpts |= SourceFile::ParsingFlags::DisableDelayedBodies;
-  performSemaUpTo(SourceFile::Unprocessed, parsingOpts);
+  performSemaUpTo(SourceFile::Unprocessed);
   assert(Context->LoadedModules.size() == 1 &&
          "Loaded a module during parse-only");
 }
@@ -755,8 +749,7 @@ void CompilerInstance::performSema() {
   performSemaUpTo(SourceFile::TypeChecked);
 }
 
-void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage,
-                                       SourceFile::ParsingOptions POpts) {
+void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage) {
   FrontendStatsTracer tracer(getStatsReporter(), "perform-sema");
 
   ModuleDecl *mainModule = getMainModule();
@@ -765,7 +758,7 @@ void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage,
   // Make sure the main file is the first file in the module, so do this now.
   if (MainBufferID != NO_SUCH_BUFFER) {
     auto *mainFile = createSourceFileForMainModule(
-        Invocation.getSourceFileKind(), MainBufferID, POpts);
+        Invocation.getSourceFileKind(), MainBufferID);
     mainFile->SyntaxParsingCache = Invocation.getMainFileSyntaxParsingCache();
   }
 
@@ -789,8 +782,7 @@ void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage,
       SF = &getMainModule()->getMainSourceFile(Invocation.getSourceFileKind());
     } else {
       // Otherwise create a library file.
-      SF = createSourceFileForMainModule(SourceFileKind::Library,
-                                         BufferID, POpts);
+      SF = createSourceFileForMainModule(SourceFileKind::Library, BufferID);
     }
     // Trigger parsing of the file.
     if (LimitStage == SourceFile::Unprocessed) {
@@ -898,10 +890,28 @@ void CompilerInstance::finishTypeChecking() {
 }
 
 SourceFile *CompilerInstance::createSourceFileForMainModule(
-    SourceFileKind fileKind, Optional<unsigned> bufferID,
-    SourceFile::ParsingOptions opts) {
+    SourceFileKind fileKind, Optional<unsigned> bufferID) {
   ModuleDecl *mainModule = getMainModule();
 
+  const auto &frontendOpts = Invocation.getFrontendOptions();
+  const auto action = frontendOpts.RequestedAction;
+
+  auto opts = SourceFile::getDefaultParsingOptions(getASTContext().LangOpts);
+  if (FrontendOptions::shouldActionOnlyParse(action)) {
+    // Generally in a parse-only invocation, we want to disable #if evaluation.
+    // However, there are a couple of modes where we need to know which clauses
+    // are active.
+    if (action != FrontendOptions::ActionType::EmitImportedModules &&
+        action != FrontendOptions::ActionType::ScanDependencies) {
+      opts |= SourceFile::ParsingFlags::DisablePoundIfEvaluation;
+    }
+
+    // If we need to dump the parse tree, disable delayed bodies as we want to
+    // show everything.
+    if (action == FrontendOptions::ActionType::DumpParse)
+      opts |= SourceFile::ParsingFlags::DisableDelayedBodies;
+  }
+
   auto isPrimary = bufferID && isPrimaryInput(*bufferID);
   if (isPrimary || isWholeModuleCompilation()) {
     // Disable delayed body parsing for primaries.
@@ -917,7 +927,6 @@ SourceFile *CompilerInstance::createSourceFileForMainModule(
   if (isPrimary) {
     opts |= SourceFile::ParsingFlags::EnableInterfaceHash;
   }
-  opts |= SourceFile::getDefaultParsingOptions(getASTContext().LangOpts);
 
   auto *inputFile = new (*Context)
       SourceFile(*mainModule, fileKind, bufferID, opts, isPrimary);

lib/FrontendTool/FrontendTool.cpp

@@ -1274,14 +1274,7 @@ static bool performCompile(CompilerInstance &Instance,
   }
 
   if (FrontendOptions::shouldActionOnlyParse(Action)) {
-    // Disable delayed parsing of type and function bodies when we've been
-    // asked to dump the resulting AST.
-    bool CanDelayBodies = Action != FrontendOptions::ActionType::DumpParse;
-    bool EvaluateConditionals =
-        Action == FrontendOptions::ActionType::EmitImportedModules
-        || Action == FrontendOptions::ActionType::ScanDependencies;
-    Instance.performParseOnly(EvaluateConditionals,
-                              CanDelayBodies);
+    Instance.performParseOnly();
   } else if (Action == FrontendOptions::ActionType::ResolveImports) {
     Instance.performParseAndResolveImportsOnly();
   } else {

lib/IDE/Refactoring.cpp

@@ -1174,6 +1174,7 @@ getNotableRegions(StringRef SourceText, unsigned NameOffset, StringRef Name,
   Invocation.getFrontendOptions().InputsAndOutputs.addInput(
       InputFile("<extract>", true, InputBuffer.get()));
   Invocation.getFrontendOptions().ModuleName = "extract";
+  Invocation.getLangOptions().DisablePoundIfEvaluation = true;
 
   auto Instance = std::make_unique<swift::CompilerInstance>();
   if (Instance->setup(Invocation))

tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp

@@ -808,6 +808,7 @@ static bool makeParserAST(CompilerInstance &CI, StringRef Text,
   Invocation.getFrontendOptions().InputsAndOutputs.clearInputs();
   Invocation.setModuleName("main");
   Invocation.setInputKind(InputFileKind::Swift);
+  Invocation.getLangOptions().DisablePoundIfEvaluation = true;
 
   std::unique_ptr<llvm::MemoryBuffer> Buf;
   Buf = llvm::MemoryBuffer::getMemBuffer(Text, "<module-interface>");
@@ -1406,7 +1407,7 @@ SourceFile *SwiftLangSupport::getSyntacticSourceFile(
     Error = "Compiler invocation set up failed";
     return nullptr;
   }
-  ParseCI.performParseOnly(/*EvaluateConditionals*/true);
+  ParseCI.performParseOnly();
 
   SourceFile *SF = nullptr;
   unsigned BufferID = ParseCI.getInputBufferIDs().back();

tools/SourceKit/lib/SwiftLang/SwiftEditorInterfaceGen.cpp

@@ -234,6 +234,7 @@ static bool makeParserAST(CompilerInstance &CI, StringRef Text,
   Invocation.getFrontendOptions().InputsAndOutputs.clearInputs();
   Invocation.setModuleName("main");
   Invocation.setInputKind(InputFileKind::Swift);
+  Invocation.getLangOptions().DisablePoundIfEvaluation = true;
 
   std::unique_ptr<llvm::MemoryBuffer> Buf;
   Buf = llvm::MemoryBuffer::getMemBuffer(Text, "<module-interface>");

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

@@ -1707,6 +1707,9 @@ static int doPrintAST(const CompilerInvocation &InitInvok,
   CompilerInvocation Invocation(InitInvok);
   Invocation.getFrontendOptions().InputsAndOutputs.addInputFile(SourceFilename);
 
+  if (!RunTypeChecker)
+    Invocation.getLangOptions().DisablePoundIfEvaluation = true;
+
   CompilerInstance CI;
 
   // Display diagnostics to stderr.