Requestify SIL parsing

Replace `parseSourceFileSIL` with
ParseSILModuleRequest, and add some convenience
members to SILGenDescriptor to retrieve the
SourceFile to be parsed.

Author: hamishknight

include/swift/AST/SILGenRequests.h

@@ -41,7 +41,7 @@ void reportEvaluatedRequest(UnifiedStatsReporter &stats,
                             const Request &request);
 
 struct SILGenDescriptor {
-  llvm::PointerUnion<ModuleDecl *, FileUnit *> context;
+  llvm::PointerUnion<FileUnit *, ModuleDecl *> context;
   Lowering::TypeConverter &conv;
   const SILOptions &opts;
 
@@ -73,6 +73,17 @@ struct SILGenDescriptor {
                                          const SILOptions &opts) {
     return SILGenDescriptor{mod, conv, opts};
   }
+
+  /// For a single file input, returns a single element array containing that
+  /// file. Otherwise returns an array of each file in the module.
+  ArrayRef<FileUnit *> getFiles() const;
+
+  /// If the module or file contains SIL that needs parsing, returns the file
+  /// to be parsed, or \c nullptr if parsing isn't required.
+  SourceFile *getSourceFileToParse() const;
+
+  /// Whether the SIL is being emitted for a whole module.
+  bool isWholeModule() const;
 };
 
 void simple_display(llvm::raw_ostream &out, const SILGenDescriptor &d);
@@ -120,6 +131,22 @@ class SILGenWholeModuleRequest :
   bool isCached() const { return true; }
 };
 
+/// Parses a .sil file into a SILModule.
+class ParseSILModuleRequest
+    : public SimpleRequest<ParseSILModuleRequest,
+                           std::unique_ptr<SILModule>(SILGenDescriptor),
+                           RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  std::unique_ptr<SILModule>
+  evaluate(Evaluator &evaluator, SILGenDescriptor desc) const;
+};
+
 /// The zone number for SILGen.
 #define SWIFT_TYPEID_ZONE SILGen
 #define SWIFT_TYPEID_HEADER "swift/AST/SILGenTypeIDZone.def"

include/swift/AST/SILGenTypeIDZone.def

@@ -20,3 +20,6 @@ SWIFT_REQUEST(SILGen, SILGenSourceFileRequest,
 SWIFT_REQUEST(SILGen, SILGenWholeModuleRequest,
               std::unique_ptr<SILModule>(SILGenDescriptor),
               Uncached, NoLocationInfo)
+SWIFT_REQUEST(SILGen, ParseSILModuleRequest,
+              std::unique_ptr<SILModule>(SILGenDescriptor),
+              Uncached, NoLocationInfo)

include/swift/Subsystems.h

@@ -102,9 +102,6 @@ namespace swift {
 
   /// @}
 
-  /// Parse a source file's SIL declarations into a given SIL module.
-  void parseSourceFileSIL(SourceFile &SF, SILParserState *sil);
-
   /// Finish the code completion.
   void performCodeCompletionSecondPass(SourceFile &SF,
                                        CodeCompletionCallbacksFactory &Factory);

lib/SIL/Parser/ParseSIL.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SILGenRequests.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Defer.h"
@@ -105,17 +106,23 @@ SILParserState::SILParserState(SILModule *M)
 
 SILParserState::~SILParserState() = default;
 
-void swift::parseSourceFileSIL(SourceFile &SF, SILParserState *sil) {
-  auto bufferID = SF.getBufferID();
+std::unique_ptr<SILModule>
+ParseSILModuleRequest::evaluate(Evaluator &evaluator,
+                                SILGenDescriptor desc) const {
+  auto *SF = desc.getSourceFileToParse();
+  assert(SF);
+
+  auto bufferID = SF->getBufferID();
   assert(bufferID);
 
-  FrontendStatsTracer tracer(SF.getASTContext().Stats,
-                             "Parsing SIL");
-  Parser parser(*bufferID, SF, sil->Impl.get(),
-                /*persistentParserState*/ nullptr,
-                /*syntaxTreeCreator*/ nullptr);
+  auto *mod = SF->getParentModule();
+  auto silMod = SILModule::createEmptyModule(mod, desc.conv, desc.opts,
+                                             desc.isWholeModule());
+  SILParserState parserState(silMod.get());
+  Parser parser(*bufferID, *SF, parserState.Impl.get());
   PrettyStackTraceParser StackTrace(parser);
   parser.parseTopLevelSIL();
+  return silMod;
 }
 
 //===----------------------------------------------------------------------===//

lib/SILGen/SILGenRequests.cpp

@@ -56,6 +56,49 @@ evaluator::DependencySource SILGenSourceFileRequest::readDependencySource(
   };
 }
 
+ArrayRef<FileUnit *> SILGenDescriptor::getFiles() const {
+  if (auto *mod = context.dyn_cast<ModuleDecl *>())
+    return mod->getFiles();
+
+  // For a single file, we can form an ArrayRef that points at its storage in
+  // the union.
+  return llvm::makeArrayRef(*context.getAddrOfPtr1());
+}
+
+bool SILGenDescriptor::isWholeModule() const {
+  return context.is<ModuleDecl *>();
+}
+
+SourceFile *SILGenDescriptor::getSourceFileToParse() const {
+#ifndef NDEBUG
+  auto sfCount = llvm::count_if(getFiles(), [](FileUnit *file) {
+    return isa<SourceFile>(file);
+  });
+  auto silFileCount = llvm::count_if(getFiles(), [](FileUnit *file) {
+    auto *SF = dyn_cast<SourceFile>(file);
+    return SF && SF->Kind == SourceFileKind::SIL;
+  });
+  assert(silFileCount == 0 || (silFileCount == 1 && sfCount == 1) &&
+         "Cannot currently mix a .sil file with other SourceFiles");
+#endif
+
+  for (auto *file : getFiles()) {
+    // Skip other kinds of files.
+    auto *SF = dyn_cast<SourceFile>(file);
+    if (!SF)
+      continue;
+
+    // Given the above precondition that a .sil file isn't mixed with other
+    // SourceFiles, we can return a SIL file if we have it, or return nullptr.
+    if (SF->Kind == SourceFileKind::SIL) {
+      return SF;
+    } else {
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
 // Define request evaluation functions for each of the SILGen requests.
 static AbstractRequestFunction *silGenRequestFunctions[] = {
 #define SWIFT_REQUEST(Zone, Name, Sig, Caching, LocOptions)                    \