Merge pull request swiftlang#31609 from hamishknight/ill-sil-you-in-later

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/Frontend/Frontend.h

@@ -425,7 +425,6 @@ class CompilerInstance {
   DiagnosticEngine Diagnostics{SourceMgr};
   std::unique_ptr<ASTContext> Context;
   std::unique_ptr<Lowering::TypeConverter> TheSILTypes;
-  std::unique_ptr<SILModule> TheSILModule;
   std::unique_ptr<DiagnosticVerifier> DiagVerifier;
 
   /// Null if no tracker.
@@ -498,8 +497,6 @@ class CompilerInstance {
 
   Lowering::TypeConverter &getSILTypes();
 
-  void createSILModule();
-
   void addDiagnosticConsumer(DiagnosticConsumer *DC) {
     Diagnostics.addConsumer(*DC);
   }
@@ -517,16 +514,6 @@ class CompilerInstance {
 
   UnifiedStatsReporter *getStatsReporter() const { return Stats.get(); }
 
-  SILModule *getSILModule() {
-    return TheSILModule.get();
-  }
-
-  std::unique_ptr<SILModule> takeSILModule();
-
-  bool hasSILModule() {
-    return static_cast<bool>(TheSILModule);
-  }
-
   ModuleDecl *getMainModule() const;
 
   MemoryBufferSerializedModuleLoader *
@@ -659,9 +646,6 @@ class CompilerInstance {
 public:
   void freeASTContext();
 
-  /// Frees up the SILModule that this instance is holding on to.
-  void freeSILModule();
-
 private:
   /// Load stdlib & return true if should continue, i.e. no error
   bool loadStdlib();

include/swift/Parse/Parser.h

@@ -888,7 +888,8 @@ class Parser {
   void parseTopLevel(SmallVectorImpl<Decl *> &decls);
 
   /// Parse the top-level SIL decls into the SIL module.
-  void parseTopLevelSIL();
+  /// \returns \c true if there was a parsing error.
+  bool parseTopLevelSIL();
 
   /// Flags that control the parsing of declarations.
   enum ParseDeclFlags {

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/Frontend/Frontend.cpp

@@ -186,14 +186,6 @@ Lowering::TypeConverter &CompilerInstance::getSILTypes() {
   return *tc;
 }
 
-void CompilerInstance::createSILModule() {
-  assert(MainModule && "main module not created yet");
-  // Assume WMO if a -primary-file option was not provided.
-  TheSILModule = SILModule::createEmptyModule(
-      getMainModule(), getSILTypes(), Invocation.getSILOptions(),
-      Invocation.getFrontendOptions().InputsAndOutputs.isWholeModule());
-}
-
 void CompilerInstance::recordPrimaryInputBuffer(unsigned BufID) {
   PrimaryBufferIDs.insert(BufID);
 }
@@ -678,10 +670,6 @@ CompilerInstance::openModuleDoc(const InputFile &input) {
   return None;
 }
 
-std::unique_ptr<SILModule> CompilerInstance::takeSILModule() {
-  return std::move(TheSILModule);
-}
-
 /// Implicitly import the SwiftOnoneSupport module in non-optimized
 /// builds. This allows for use of popular specialized functions
 /// from the standard library, which makes the non-optimized builds
@@ -759,14 +747,6 @@ void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage) {
   ModuleDecl *mainModule = getMainModule();
   Context->LoadedModules[mainModule->getName()] = mainModule;
 
-  if (Invocation.getInputKind() == InputFileKind::SIL) {
-    assert(!InputSourceCodeBufferIDs.empty());
-    assert(InputSourceCodeBufferIDs.size() == 1);
-    assert(MainBufferID != NO_SUCH_BUFFER);
-    assert(isPrimaryInput(MainBufferID) || isWholeModuleCompilation());
-    createSILModule();
-  }
-
   if (Invocation.getImplicitStdlibKind() == ImplicitStdlibKind::Stdlib) {
     if (!loadStdlib())
       return;
@@ -804,13 +784,6 @@ void CompilerInstance::performSemaUpTo(SourceFile::ASTStage_t LimitStage) {
 
   forEachFileToTypeCheck([&](SourceFile &SF) {
     performTypeChecking(SF);
-
-    // Parse the SIL decls if needed.
-    // TODO: Requestify SIL parsing.
-    if (TheSILModule) {
-      SILParserState SILContext(TheSILModule.get());
-      parseSourceFileSIL(SF, &SILContext);
-    }
   });
 
   finishTypeChecking();
@@ -986,8 +959,6 @@ void CompilerInstance::freeASTContext() {
   PrimarySourceFiles.clear();
 }
 
-void CompilerInstance::freeSILModule() { TheSILModule.reset(); }
-
 /// Perform "stable" optimizations that are invariant across compiler versions.
 static bool performMandatorySILPasses(CompilerInvocation &Invocation,
                                       SILModule *SM) {

lib/FrontendTool/FrontendTool.cpp

@@ -1066,17 +1066,11 @@ static bool performCompileStepsPostSILGen(CompilerInstance &Instance,
 static bool performCompileStepsPostSema(CompilerInstance &Instance,
                                         int &ReturnValue,
                                         FrontendObserver *observer) {
-  auto mod = Instance.getMainModule();
-  if (auto SM = Instance.takeSILModule()) {
-    const PrimarySpecificPaths PSPs =
-        Instance.getPrimarySpecificPathsForAtMostOnePrimary();
-    return performCompileStepsPostSILGen(Instance, std::move(SM), mod, PSPs,
-                                         ReturnValue, observer);
-  }
-
   const auto &Invocation = Instance.getInvocation();
   const SILOptions &SILOpts = Invocation.getSILOptions();
   const FrontendOptions &opts = Invocation.getFrontendOptions();
+
+  auto *mod = Instance.getMainModule();
   if (!opts.InputsAndOutputs.hasPrimaryInputs()) {
     // If there are no primary inputs the compiler is in WMO mode and builds one
     // SILModule for the entire module.
@@ -1466,30 +1460,24 @@ static bool validateTBDIfNeeded(const CompilerInvocation &Invocation,
   }
 }
 
-enum class DeallocatableResources {
-  None,
-  SILModule,
-  SILModuleAndASTContext,
-};
-static DeallocatableResources
-computeDeallocatableResources(const CompilerInstance &Instance) {
-  // If the stats reporter is installed, we need the ASTContext and SILModule
-  // to live through the entire compilation process.
+static void freeASTContextIfPossible(CompilerInstance &Instance) {
+  // If the stats reporter is installed, we need the ASTContext to live through
+  // the entire compilation process.
   if (Instance.getASTContext().Stats) {
-    return DeallocatableResources::None;
+    return;
   }
 
   // If we're going to dump the API of the module, we cannot tear down
   // the ASTContext, as that would cause the module to be freed prematurely.
   const auto &opts = Instance.getInvocation().getFrontendOptions();
   if (!opts.DumpAPIPath.empty()) {
-    return DeallocatableResources::SILModule;
+    return;
   }
 
   // Verifying incremental dependencies relies on access to the Swift Module's
-  // source files. We can still free the SIL module, though.
+  // source files.
   if (opts.EnableIncrementalDependencyVerifier) {
-    return DeallocatableResources::SILModule;
+    return;
   }
 
   // If there are multiple primary inputs it is too soon to free
@@ -1498,29 +1486,14 @@ computeDeallocatableResources(const CompilerInstance &Instance) {
   // unlikely to reduce the peak heap size. So, only optimize the
   // single-primary-case (or WMO).
   if (opts.InputsAndOutputs.hasMultiplePrimaryInputs()) {
-    return DeallocatableResources::SILModule;
+    return;
   }
 
-  return DeallocatableResources::SILModuleAndASTContext;
-}
+  // Make sure we emit dependencies now, because we can't do it after the
+  // context is gone.
+  emitReferenceDependenciesForAllPrimaryInputsIfNeeded(Instance);
 
-static void freeDeallocatableResourcesIfPossible(CompilerInstance &Instance) {
-  switch (computeDeallocatableResources(Instance)) {
-  case DeallocatableResources::None:
-    break;
-  case DeallocatableResources::SILModule:
-    Instance.freeSILModule();
-    break;
-  case DeallocatableResources::SILModuleAndASTContext:
-    Instance.freeSILModule();
-
-    // Make sure we emit dependencies now, because we can't do it after the
-    // context is gone.
-    emitReferenceDependenciesForAllPrimaryInputsIfNeeded(Instance);
-
-    Instance.freeASTContext();
-    break;
-  }
+  Instance.freeASTContext();
 }
 
 static bool generateCode(CompilerInstance &Instance, StringRef OutputFilename,
@@ -1533,7 +1506,7 @@ static bool generateCode(CompilerInstance &Instance, StringRef OutputFilename,
       Instance.getASTContext().LangOpts.EffectiveLanguageVersion;
 
   // Free up some compiler resources now that we have an IRModule.
-  freeDeallocatableResourcesIfPossible(Instance);
+  freeASTContextIfPossible(Instance);
 
   // Now that we have a single IR Module, hand it over to performLLVM.
   return performLLVM(opts, Instance.getDiags(), nullptr, HashGlobal, IRModule,

lib/Parse/ParseDecl.cpp

@@ -241,7 +241,7 @@ void Parser::parseTopLevel(SmallVectorImpl<Decl *> &decls) {
   TokReceiver->finalize();
 }
 
-void Parser::parseTopLevelSIL() {
+bool Parser::parseTopLevelSIL() {
   assert(SIL && isInSILMode());
 
   // Prime the lexer.
@@ -253,6 +253,7 @@ void Parser::parseTopLevelSIL() {
       skipSingle();
   };
 
+  auto hadError = false;
   while (!Tok.is(tok::eof)) {
     // If we run into a Swift decl, skip over until we find the next SIL decl.
     if (isStartOfSwiftDecl()) {
@@ -269,6 +270,7 @@ void Parser::parseTopLevelSIL() {
       if (SIL->parse##NAME(*this)) {                                           \
         Lexer::SILBodyRAII sbr(*L);                                            \
         skipToNextSILDecl();                                                   \
+        hadError = true;                                                       \
       }                                                                        \
       break;                                                                   \
     }
@@ -288,9 +290,11 @@ void Parser::parseTopLevelSIL() {
       // or a SIL decl. Emit an error and skip ahead to the next SIL decl.
       diagnose(Tok, diag::expected_sil_keyword);
       skipToNextSILDecl();
+      hadError = true;
       break;
     }
   }
+  return hadError;
 }
 
 ParserResult<AvailableAttr> Parser::parseExtendedAvailabilitySpecList(

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,30 @@ 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();
+
+  auto hadError = parser.parseTopLevelSIL();
+  if (hadError) {
+    // The rest of the SIL pipeline expects well-formed SIL, so if we encounter
+    // a parsing error, just return an empty SIL module.
+    return SILModule::createEmptyModule(mod, desc.conv, desc.opts,
+                                        desc.isWholeModule());
+  }
+  return silMod;
 }
 
 //===----------------------------------------------------------------------===//

lib/SILGen/SILGen.cpp

@@ -1860,6 +1860,11 @@ class SILGenModuleRAII {
 std::unique_ptr<SILModule>
 SILGenSourceFileRequest::evaluate(Evaluator &evaluator,
                                   SILGenDescriptor desc) const {
+  // If we have a .sil file to parse, defer to the parsing request.
+  if (desc.getSourceFileToParse()) {
+    return llvm::cantFail(evaluator(ParseSILModuleRequest{desc}));
+  }
+
   auto *unit = desc.context.get<FileUnit *>();
   auto *mod = unit->getParentModule();
   auto M = std::unique_ptr<SILModule>(
@@ -1879,6 +1884,11 @@ SILGenSourceFileRequest::evaluate(Evaluator &evaluator,
 std::unique_ptr<SILModule>
 SILGenWholeModuleRequest::evaluate(Evaluator &evaluator,
                                    SILGenDescriptor desc) const {
+  // If we have a .sil file to parse, defer to the parsing request.
+  if (desc.getSourceFileToParse()) {
+    return llvm::cantFail(evaluator(ParseSILModuleRequest{desc}));
+  }
+
   auto *mod = desc.context.get<ModuleDecl *>();
   auto M = std::unique_ptr<SILModule>(
       new SILModule(mod, desc.conv, desc.opts, mod, /*wholeModule*/ true));