Sink some parsing options into SourceFile::ParsingFlags

hamishknight · hamishknight · commit 60eae88fd1d2 · 2020-06-03T11:03:55.000-07:00
Sink the `BuildSyntaxTree` and
`CollectParsedTokens` bits into
`SourceFile::ParsingFlags`, with a static method
to get the parsing options from the lang opts.

Also add a parsing flag for enabling the interface
hash, which can be used instead of calling
`enableInterfaceHash`.
diff --git a/include/swift/AST/SourceFile.h b/include/swift/AST/SourceFile.h
@@ -32,8 +32,6 @@ class SourceFile final : public FileUnit {
   friend class ParseSourceFileRequest;
 
 public:
-  struct SourceFileSyntaxInfo;
-
   /// Possible attributes for imports in source files.
   enum class ImportFlags {
     /// The imported module is exposed to anyone who imports the parent module.
@@ -110,12 +108,24 @@ class SourceFile final : public FileUnit {
     /// and adjust the client call 'performParseOnly'.
     DisablePoundIfEvaluation = 1 << 1,
 
+    /// Whether to build a syntax tree.
+    BuildSyntaxTree = 1 << 2,
+
+    /// Whether to save the file's parsed tokens.
+    CollectParsedTokens = 1 << 3,
+
+    /// Whether to compute the interface hash of the file.
+    EnableInterfaceHash = 1 << 4,
+
     /// Whether to suppress warnings when parsing. This is set for secondary
     /// files, as they get parsed multiple times.
-    SuppressWarnings = 1 << 2
+    SuppressWarnings = 1 << 5,
   };
   using ParsingOptions = OptionSet<ParsingFlags>;
 
+  /// Retrieve the parsing options specified in the LangOptions.
+  static ParsingOptions getDefaultParsingOptions(const LangOptions &langOpts);
+
 private:
   std::unique_ptr<SourceLookupCache> Cache;
   SourceLookupCache &getCache() const;
@@ -313,7 +323,6 @@ class SourceFile final : public FileUnit {
   llvm::StringMap<SourceFilePathInfo> getInfoForUsedFilePaths() const;
 
   SourceFile(ModuleDecl &M, SourceFileKind K, Optional<unsigned> bufferID,
-             bool KeepParsedTokens = false, bool KeepSyntaxTree = false,
              ParsingOptions parsingOpts = {}, bool isPrimary = false);
 
   ~SourceFile();
@@ -544,13 +553,9 @@ class SourceFile final : public FileUnit {
   /// Set the root refinement context for the file.
   void setTypeRefinementContext(TypeRefinementContext *TRC);
 
-  void enableInterfaceHash() {
-    assert(!hasInterfaceHash());
-    InterfaceHash.emplace();
-  }
-
+  /// Whether this file has an interface hash available.
   bool hasInterfaceHash() const {
-    return InterfaceHash.hasValue();
+    return ParsingOpts.contains(ParsingFlags::EnableInterfaceHash);
   }
 
   NullablePtr<llvm::MD5> getInterfaceHashPtr() {
@@ -608,7 +613,8 @@ class SourceFile final : public FileUnit {
   /// source file.
   Optional<std::vector<Token>> AllCollectedTokens;
 
-  std::unique_ptr<SourceFileSyntaxInfo> SyntaxInfo;
+  /// The root of the syntax tree representing the source file.
+  std::unique_ptr<syntax::SourceFileSyntax> SyntaxRoot;
 };
 
 inline SourceFile::ParsingOptions operator|(SourceFile::ParsingFlags lhs,
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -1077,24 +1077,17 @@ LookupConformanceInModuleRequest::evaluate(
   return ProtocolConformanceRef(conformance);
 }
 
-struct SourceFile::SourceFileSyntaxInfo {
-  const bool Enable;
-  /// The root of the syntax tree representing the source file.
-  Optional<syntax::SourceFileSyntax> SyntaxRoot;
-  SourceFileSyntaxInfo(bool Enable): Enable(Enable) {}
-};
-
 bool SourceFile::hasSyntaxRoot() const {
-  return SyntaxInfo->SyntaxRoot.hasValue();
+  return ParsingOpts.contains(ParsingFlags::BuildSyntaxTree);
 }
 
 syntax::SourceFileSyntax SourceFile::getSyntaxRoot() const {
   assert(hasSyntaxRoot() && "no syntax root is set.");
-  return *SyntaxInfo->SyntaxRoot;
+  return *SyntaxRoot;
 }
 
 void SourceFile::setSyntaxRoot(syntax::SourceFileSyntax &&Root) {
-  SyntaxInfo->SyntaxRoot.emplace(Root);
+  SyntaxRoot = std::make_unique<syntax::SourceFileSyntax>(std::move(Root));
 }
 
 void DirectOperatorLookupRequest::writeDependencySink(
@@ -2216,11 +2209,9 @@ ModuleDecl::computeMagicFileStringMap(bool shouldDiagnose) const {
 
 SourceFile::SourceFile(ModuleDecl &M, SourceFileKind K,
                        Optional<unsigned> bufferID,
-                       bool KeepParsedTokens, bool BuildSyntaxTree,
                        ParsingOptions parsingOpts, bool isPrimary)
     : FileUnit(FileUnitKind::Source, M), BufferID(bufferID ? *bufferID : -1),
-      ParsingOpts(parsingOpts), IsPrimary(isPrimary), Kind(K),
-      SyntaxInfo(new SourceFileSyntaxInfo(BuildSyntaxTree)) {
+      ParsingOpts(parsingOpts), IsPrimary(isPrimary), Kind(K) {
   M.getASTContext().addDestructorCleanup(*this);
 
   assert(!IsPrimary || M.isMainModule() &&
@@ -2231,7 +2222,11 @@ SourceFile::SourceFile(ModuleDecl &M, SourceFileKind K,
     assert(!problem && "multiple main files?");
     (void)problem;
   }
-  if (KeepParsedTokens) {
+
+  if (hasInterfaceHash()) {
+    InterfaceHash.emplace();
+  }
+  if (shouldCollectTokens()) {
     AllCollectedTokens = std::vector<Token>();
   }
 }
@@ -2241,25 +2236,29 @@ std::vector<Token> &SourceFile::getTokenVector() {
   return *AllCollectedTokens;
 }
 
+SourceFile::ParsingOptions
+SourceFile::getDefaultParsingOptions(const LangOptions &langOpts) {
+  ParsingOptions opts;
+  if (langOpts.BuildSyntaxTree)
+    opts |= ParsingFlags::BuildSyntaxTree;
+  if (langOpts.CollectParsedToken)
+    opts |= ParsingFlags::CollectParsedTokens;
+  return opts;
+}
+
 ArrayRef<Token> SourceFile::getAllTokens() const {
   assert(shouldCollectTokens() && "Disabled");
   return *AllCollectedTokens;
 }
 
 bool SourceFile::shouldCollectTokens() const {
-  switch (Kind) {
-  case SourceFileKind::Library:
-  case SourceFileKind::Main:
-  case SourceFileKind::Interface:
-    return (bool)AllCollectedTokens;
-  case SourceFileKind::SIL:
-    return false;
-  }
-  llvm_unreachable("unhandled kind");
+  return Kind != SourceFileKind::SIL &&
+         ParsingOpts.contains(ParsingFlags::CollectParsedTokens);
 }
 
 bool SourceFile::shouldBuildSyntaxTree() const {
-  return Kind != SourceFileKind::SIL && SyntaxInfo->Enable;
+  return Kind != SourceFileKind::SIL &&
+         ParsingOpts.contains(ParsingFlags::BuildSyntaxTree);
 }
 
 bool SourceFile::hasDelayedBodyParsing() const {
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -902,15 +902,17 @@ SourceFile *CompilerInstance::createSourceFileForMainModule(
     opts |= SourceFile::ParsingFlags::SuppressWarnings;
   }
 
-  SourceFile *inputFile = new (*Context)
-      SourceFile(*mainModule, fileKind, bufferID,
-                 Invocation.getLangOptions().CollectParsedToken,
-                 Invocation.getLangOptions().BuildSyntaxTree, opts, isPrimary);
-  MainModule->addFile(*inputFile);
-
+  // Enable interface hash computation for primaries, but not in WMO, as it's
+  // only currently needed for incremental mode.
   if (isPrimary) {
-    inputFile->enableInterfaceHash();
+    opts |= SourceFile::ParsingFlags::EnableInterfaceHash;
   }
+  opts |= SourceFile::getDefaultParsingOptions(getASTContext().LangOpts);
+
+  auto *inputFile = new (*Context)
+      SourceFile(*mainModule, fileKind, bufferID, opts, isPrimary);
+  MainModule->addFile(*inputFile);
+
   return inputFile;
 }
 
diff --git a/lib/IDE/CompletionInstance.cpp b/lib/IDE/CompletionInstance.cpp
@@ -328,9 +328,7 @@ bool CompletionInstance::performCachedOperationIfPossible(
   registerSILGenRequestFunctions(tmpCtx->evaluator);
   ModuleDecl *tmpM = ModuleDecl::create(Identifier(), *tmpCtx);
   SourceFile *tmpSF = new (*tmpCtx)
-      SourceFile(*tmpM, oldSF->Kind, tmpBufferID, /*KeepParsedTokens=*/false,
-                 /*BuildSyntaxTree=*/false, oldSF->getParsingOptions());
-  tmpSF->enableInterfaceHash();
+      SourceFile(*tmpM, oldSF->Kind, tmpBufferID, oldSF->getParsingOptions());
 
   // FIXME: Since we don't setup module loaders on the temporary AST context,
   // 'canImport()' conditional compilation directive always fails. That causes
@@ -441,10 +439,9 @@ bool CompletionInstance::performCachedOperationIfPossible(
     auto &Ctx = oldM->getASTContext();
     auto *newM = ModuleDecl::createMainModule(Ctx, oldM->getName(),
                                               oldM->getImplicitImportInfo());
-    auto *newSF =
-        new (Ctx) SourceFile(*newM, SourceFileKind::Main, newBufferID);
+    auto *newSF = new (Ctx) SourceFile(*newM, SourceFileKind::Main, newBufferID,
+                                       oldSF->getParsingOptions());
     newM->addFile(*newSF);
-    newSF->enableInterfaceHash();
 
     // Tell the compiler instance we've replaced the main module.
     CI.setMainModule(newM);
diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
@@ -109,6 +109,7 @@ void tokenize(const LangOptions &LangOpts, const SourceManager &SM,
 
 using namespace swift;
 using namespace swift::syntax;
+using ParsingFlags = SourceFile::ParsingFlags;
 
 void SILParserStateBase::anchor() { }
 
@@ -1196,14 +1197,17 @@ struct ParserUnit::Implementation {
                  const LangOptions &Opts, const TypeCheckerOptions &TyOpts,
                  StringRef ModuleName,
                  std::shared_ptr<SyntaxParseActions> spActions)
-      : SPActions(std::move(spActions)),
-        LangOpts(Opts), TypeCheckerOpts(TyOpts), Diags(SM),
-        Ctx(*ASTContext::get(LangOpts, TypeCheckerOpts, SearchPathOpts, SM, Diags)),
-        SF(new (Ctx) SourceFile(
-            *ModuleDecl::create(Ctx.getIdentifier(ModuleName), Ctx), SFKind,
-            BufferID, Opts.CollectParsedToken, Opts.BuildSyntaxTree,
-            SourceFile::ParsingFlags::DisableDelayedBodies |
-                SourceFile::ParsingFlags::DisablePoundIfEvaluation)) {}
+      : SPActions(std::move(spActions)), LangOpts(Opts),
+        TypeCheckerOpts(TyOpts), Diags(SM),
+        Ctx(*ASTContext::get(LangOpts, TypeCheckerOpts, SearchPathOpts, SM,
+                             Diags)) {
+    auto parsingOpts = SourceFile::getDefaultParsingOptions(LangOpts);
+    parsingOpts |= ParsingFlags::DisableDelayedBodies;
+    parsingOpts |= ParsingFlags::DisablePoundIfEvaluation;
+
+    auto *M = ModuleDecl::create(Ctx.getIdentifier(ModuleName), Ctx);
+    SF = new (Ctx) SourceFile(*M, SFKind, BufferID, parsingOpts);
+  }
 
   ~Implementation() {
     // We need to delete the parser before the context so that it can finalize
diff --git a/lib/Sema/SourceLoader.cpp b/lib/Sema/SourceLoader.cpp
@@ -120,10 +120,9 @@ ModuleDecl *SourceLoader::loadModule(SourceLoc importLoc,
     importMod->setResilienceStrategy(ResilienceStrategy::Resilient);
   Ctx.LoadedModules[moduleID.Item] = importMod;
 
-  auto *importFile = new (Ctx) SourceFile(*importMod, SourceFileKind::Library,
-                                          bufferID,
-                                          Ctx.LangOpts.CollectParsedToken,
-                                          Ctx.LangOpts.BuildSyntaxTree);
+  auto *importFile =
+      new (Ctx) SourceFile(*importMod, SourceFileKind::Library, bufferID,
+                           SourceFile::getDefaultParsingOptions(Ctx.LangOpts));
   importMod->addFile(*importFile);
   performImportResolution(*importFile);
   importMod->setHasResolvedImports();
diff --git a/unittests/AST/TestContext.cpp b/unittests/AST/TestContext.cpp
@@ -43,7 +43,7 @@ TestContext::TestContext(ShouldDeclareOptionalTypes optionals)
   Ctx.LoadedModules[stdlibID] = module;
 
   FileForLookups = new (Ctx) SourceFile(*module, SourceFileKind::Library,
-                                        /*buffer*/ None, /*keeps token*/ false);
+                                        /*buffer*/ None);
   module->addFile(*FileForLookups);
 
   if (optionals == DeclareOptionalTypes) {
