[IRGen] Allow IRGenDescriptor to hold a FileUnit

This will allow it to better interact with the
SILGen descriptor.

Author: hamishknight

include/swift/AST/IRGenRequests.h

@@ -123,7 +123,7 @@ class GeneratedModule final {
 };
 
 struct IRGenDescriptor {
-  llvm::PointerUnion<ModuleDecl *, SourceFile *> Ctx;
+  llvm::PointerUnion<FileUnit *, ModuleDecl *> Ctx;
 
   const IRGenOptions &Opts;
   const TBDGenOptions &TBDOpts;
@@ -151,12 +151,12 @@ struct IRGenDescriptor {
 
 public:
   static IRGenDescriptor
-  forFile(SourceFile &SF, const IRGenOptions &Opts,
+  forFile(FileUnit *file, const IRGenOptions &Opts,
           const TBDGenOptions &TBDOpts, std::unique_ptr<SILModule> &&SILMod,
           StringRef ModuleName, const PrimarySpecificPaths &PSPs,
           StringRef PrivateDiscriminator,
           llvm::GlobalVariable **outModuleHash) {
-    return IRGenDescriptor{&SF,
+    return IRGenDescriptor{file,
                            Opts,
                            TBDOpts,
                            SILMod.release(),

include/swift/Subsystems.h

@@ -215,11 +215,11 @@ namespace swift {
                       ArrayRef<std::string> parallelOutputFilenames,
                       llvm::GlobalVariable **outModuleHash = nullptr);
 
-  /// Turn the given Swift module into either LLVM IR or native code
+  /// Turn the given Swift file into either LLVM IR or native code
   /// and return the generated LLVM IR module.
   /// If you set an outModuleHash, then you need to call performLLVM.
   GeneratedModule
-  performIRGeneration(SourceFile &SF, const IRGenOptions &Opts, 
+  performIRGeneration(FileUnit *file, const IRGenOptions &Opts, 
                       const TBDGenOptions &TBDOpts,
                       std::unique_ptr<SILModule> SILMod,
                       StringRef ModuleName, const PrimarySpecificPaths &PSPs,

lib/FrontendTool/FrontendTool.cpp

@@ -1508,7 +1508,7 @@ generateIR(const IRGenOptions &IRGenOpts, const TBDGenOptions &TBDOpts,
            llvm::GlobalVariable *&HashGlobal,
            ArrayRef<std::string> parallelOutputFilenames) {
   if (auto *SF = MSF.dyn_cast<SourceFile *>()) {
-    return performIRGeneration(*SF, IRGenOpts, TBDOpts,
+    return performIRGeneration(SF, IRGenOpts, TBDOpts,
                                std::move(SM), OutputFilename, PSPs,
                                SF->getPrivateDiscriminator().str(),
                                &HashGlobal);

lib/IRGen/IRGen.cpp

@@ -907,7 +907,8 @@ GeneratedModule IRGenRequest::evaluate(Evaluator &evaluator,
   auto SILMod = std::unique_ptr<SILModule>(desc.SILMod);
   auto *M = desc.getParentModule();
   auto filesToEmit = desc.getFiles();
-  auto *primaryFile = desc.Ctx.dyn_cast<SourceFile *>();
+  auto *primaryFile =
+      dyn_cast_or_null<SourceFile>(desc.Ctx.dyn_cast<FileUnit *>());
 
   auto &Ctx = M->getASTContext();
   assert(!Ctx.hadError());
@@ -1326,16 +1327,16 @@ GeneratedModule swift::performIRGeneration(
 }
 
 GeneratedModule swift::
-performIRGeneration(SourceFile &SF, const IRGenOptions &Opts,
+performIRGeneration(FileUnit *file, const IRGenOptions &Opts,
                     const TBDGenOptions &TBDOpts,
                     std::unique_ptr<SILModule> SILMod,
                     StringRef ModuleName, const PrimarySpecificPaths &PSPs,
                     StringRef PrivateDiscriminator,
                     llvm::GlobalVariable **outModuleHash) {
-  auto desc = IRGenDescriptor::forFile(SF, Opts, TBDOpts, std::move(SILMod),
+  auto desc = IRGenDescriptor::forFile(file, Opts, TBDOpts, std::move(SILMod),
                                        ModuleName, PSPs, PrivateDiscriminator,
                                        outModuleHash);
-  return llvm::cantFail(SF.getASTContext().evaluator(IRGenRequest{desc}));
+  return llvm::cantFail(file->getASTContext().evaluator(IRGenRequest{desc}));
 }
 
 void

lib/IRGen/IRGenRequests.cpp

@@ -39,13 +39,12 @@ llvm::orc::ThreadSafeModule GeneratedModule::intoThreadSafeContext() && {
 void swift::simple_display(llvm::raw_ostream &out,
                            const IRGenDescriptor &desc) {
   auto *MD = desc.Ctx.dyn_cast<ModuleDecl *>();
-  auto *SF = desc.Ctx.dyn_cast<SourceFile *>();
   if (MD) {
     out << "IR Generation for module " << MD->getName();
   } else {
-    assert(SF);
+    auto *file = desc.Ctx.get<FileUnit *>();
     out << "IR Generation for file ";
-    out << '\"' << SF->getFilename() << '\"';
+    simple_display(out, file);
   }
 }
 
@@ -58,29 +57,30 @@ TinyPtrVector<FileUnit *> IRGenDescriptor::getFiles() const {
   if (auto *mod = Ctx.dyn_cast<ModuleDecl *>())
     return TinyPtrVector<FileUnit *>(mod->getFiles());
 
-  // For a primary source file, we emit IR for both it and potentially its
+  // For a primary file, we emit IR for both it and potentially its
   // SynthesizedFileUnit.
-  auto *SF = Ctx.get<SourceFile *>();
+  auto *primary = Ctx.get<FileUnit *>();
   TinyPtrVector<FileUnit *> files;
-  files.push_back(SF);
-
-  if (auto *synthesizedFile = SF->getSynthesizedFile())
-    files.push_back(synthesizedFile);
+  files.push_back(primary);
 
+  if (auto *SF = dyn_cast<SourceFile>(primary)) {
+    if (auto *synthesizedFile = SF->getSynthesizedFile())
+      files.push_back(synthesizedFile);
+  }
   return files;
 }
 
 ModuleDecl *IRGenDescriptor::getParentModule() const {
-  if (auto *SF = Ctx.dyn_cast<SourceFile *>())
-    return SF->getParentModule();
+  if (auto *file = Ctx.dyn_cast<FileUnit *>())
+    return file->getParentModule();
   return Ctx.get<ModuleDecl *>();
 }
 
 std::vector<std::string> IRGenDescriptor::getLinkerDirectives() const {
   auto opts = TBDOpts;
   opts.LinkerDirectivesOnly = true;
-  if (auto *SF = Ctx.dyn_cast<SourceFile *>()) {
-    return getPublicSymbols(TBDGenDescriptor::forFile(SF, opts));
+  if (auto *file = Ctx.dyn_cast<FileUnit *>()) {
+    return getPublicSymbols(TBDGenDescriptor::forFile(file, opts));
   } else {
     auto *M = Ctx.get<ModuleDecl *>();
     return getPublicSymbols(TBDGenDescriptor::forModule(M, opts));
@@ -96,8 +96,8 @@ evaluator::DependencySource IRGenRequest::readDependencySource(
     return {nullptr, e.getActiveSourceScope()};
   }
 
-  auto *SF = desc.Ctx.get<SourceFile *>();
-  return {SF, evaluator::DependencyScope::Cascading};
+  auto *primary = desc.Ctx.get<FileUnit *>();
+  return {dyn_cast<SourceFile>(primary), evaluator::DependencyScope::Cascading};
 }
 
 // Define request evaluation functions for each of the IRGen requests.