Merge pull request swiftlang#33926 from CodaFi/just-my-kind

[NFC] Refactor InputFile

Author: CodaFi

include/swift/AST/Module.h

@@ -458,7 +458,7 @@ class ModuleDecl : public DeclContext, public TypeDecl {
 
   /// Convenience accessor for clients that know what kind of file they're
   /// dealing with.
-  SourceFile &getMainSourceFile(SourceFileKind expectedKind) const;
+  SourceFile &getMainSourceFile() const;
 
   /// Convenience accessor for clients that know what kind of file they're
   /// dealing with.

include/swift/AST/SourceFile.h

@@ -624,10 +624,8 @@ inline SourceFile::ParsingOptions operator|(SourceFile::ParsingFlags lhs,
   return SourceFile::ParsingOptions(lhs) | rhs;
 }
 
-inline SourceFile &
-ModuleDecl::getMainSourceFile(SourceFileKind expectedKind) const {
+inline SourceFile &ModuleDecl::getMainSourceFile() const {
   assert(!Files.empty() && "No files added yet");
-  assert(cast<SourceFile>(Files.front())->Kind == expectedKind);
   return *cast<SourceFile>(Files.front());
 }
 

include/swift/Frontend/Frontend.h

@@ -287,16 +287,6 @@ class CompilerInvocation {
     return FrontendOpts.ParseStdlib;
   }
 
-  void setInputKind(InputFileKind K) {
-    FrontendOpts.InputKind = K;
-  }
-
-  InputFileKind getInputKind() const {
-    return FrontendOpts.InputKind;
-  }
-
-  SourceFileKind getSourceFileKind() const;
-
   void setModuleName(StringRef Name) {
     FrontendOpts.ModuleName = Name.str();
     IRGenOpts.ModuleName = Name.str();
@@ -335,7 +325,7 @@ class CompilerInvocation {
 
   /// Retrieve the stdlib kind to implicitly import.
   ImplicitStdlibKind getImplicitStdlibKind() const {
-    if (getInputKind() == InputFileKind::SIL) {
+    if (FrontendOpts.InputMode == FrontendOptions::ParseInputMode::SIL) {
       return ImplicitStdlibKind::None;
     }
     if (getParseStdlib()) {
@@ -354,9 +344,6 @@ class CompilerInvocation {
   setUpInputForSILTool(StringRef inputFilename, StringRef moduleNameArg,
                        bool alwaysSetModuleToMain, bool bePrimary,
                        serialization::ExtendedValidationInfo &extendedInfo);
-  bool hasSerializedAST() {
-    return FrontendOpts.InputKind == InputFileKind::SwiftLibrary;
-  }
 
   const PrimarySpecificPaths &
   getPrimarySpecificPathsForAtMostOnePrimary() const;
@@ -443,9 +430,6 @@ class CompilerInstance {
   /// \c mutable as it is consumed by \c loadPartialModulesAndImplicitImports.
   mutable std::vector<ModuleBuffers> PartialModules;
 
-  enum : unsigned { NO_SUCH_BUFFER = ~0U };
-  unsigned MainBufferID = NO_SUCH_BUFFER;
-
   /// Identifies the set of input buffers in the SourceManager that are
   /// considered primaries.
   llvm::SetVector<unsigned> PrimaryBufferIDs;
@@ -565,24 +549,13 @@ class CompilerInstance {
   void setUpLLVMArguments();
   void setUpDiagnosticOptions();
   bool setUpModuleLoaders();
-  bool isInputSwift() {
-    return Invocation.getInputKind() == InputFileKind::Swift;
-  }
-  bool isInSILMode() {
-    return Invocation.getInputKind() == InputFileKind::SIL;
-  }
-
   bool setUpInputs();
   bool setUpASTContextIfNeeded();
   void setupStatsReporter();
   void setupDiagnosticVerifierIfNeeded();
   void setupDependencyTrackerIfNeeded();
   Optional<unsigned> setUpCodeCompletionBuffer();
 
-  /// Set up all state in the CompilerInstance to process the given input file.
-  /// Return true on error.
-  bool setUpForInput(const InputFile &input);
-
   /// Find a buffer for a given input file and ensure it is recorded in
   /// SourceMgr, PartialModules, or InputSourceCodeBufferIDs as appropriate.
   /// Return the buffer ID if it is not already compiled, or None if so.
@@ -626,12 +599,14 @@ class CompilerInstance {
   /// Creates a new source file for the main module.
   SourceFile *createSourceFileForMainModule(ModuleDecl *mod,
                                             SourceFileKind FileKind,
-                                            Optional<unsigned> BufferID) const;
+                                            Optional<unsigned> BufferID,
+                                            bool isMainBuffer = false) const;
 
   /// Creates all the files to be added to the main module, appending them to
   /// \p files. If a loading error occurs, returns \c true.
   bool createFilesForMainModule(ModuleDecl *mod,
                                 SmallVectorImpl<FileUnit *> &files) const;
+  SourceFile *computeMainSourceFileForModule(ModuleDecl *mod) const;
 
 public:
   void freeASTContext();

include/swift/Frontend/FrontendOptions.h

@@ -39,9 +39,6 @@ class FrontendOptions {
 public:
   FrontendInputsAndOutputs InputsAndOutputs;
 
-  /// The kind of input on which the frontend should operate.
-  InputFileKind InputKind = InputFileKind::Swift;
-
   void forAllOutputPaths(const InputFile &input,
                          llvm::function_ref<void(StringRef)> fn) const;
 
@@ -143,6 +140,14 @@ class FrontendOptions {
   /// Indicates the action the user requested that the frontend perform.
   ActionType RequestedAction = ActionType::NoneAction;
 
+  enum class ParseInputMode {
+    Swift,
+    SwiftLibrary,
+    SwiftModuleInterface,
+    SIL,
+  };
+  ParseInputMode InputMode = ParseInputMode::Swift;
+
   /// Indicates that the input(s) should be parsed as the Swift stdlib.
   bool ParseStdlib = false;
 
@@ -316,8 +321,8 @@ class FrontendOptions {
   StringRef determineFallbackModuleName() const;
 
   bool isCompilingExactlyOneSwiftFile() const {
-    return InputKind == InputFileKind::Swift &&
-           InputsAndOutputs.hasSingleInput();
+    return InputsAndOutputs.hasSingleInput() &&
+           InputMode == ParseInputMode::Swift;
   }
 
   const PrimarySpecificPaths &

include/swift/Frontend/InputFile.h

@@ -13,54 +13,80 @@
 #ifndef SWIFT_FRONTEND_INPUTFILE_H
 #define SWIFT_FRONTEND_INPUTFILE_H
 
+#include "swift/Basic/FileTypes.h"
 #include "swift/Basic/PrimarySpecificPaths.h"
 #include "swift/Basic/SupplementaryOutputPaths.h"
+#include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include <string>
 
 namespace swift {
 
-enum class InputFileKind {
-  None,
-  Swift,
-  SwiftLibrary,
-  SwiftModuleInterface,
-  SIL,
-  LLVM,
-  ObjCHeader,
-};
-
-// Inputs may include buffers that override contents, and eventually should
-// always include a buffer.
-class InputFile {
+/// An \c InputFile encapsulates information about an input passed to the
+/// frontend.
+///
+/// Compiler inputs are usually passed on the command line without a leading
+/// flag. However, there are clients that use the \c CompilerInvocation as
+/// a library like LLDB and SourceKit that generate their own \c InputFile
+/// instances programmatically. Note that an \c InputFile need not actually be
+/// backed by a physical file, nor does its file name actually reflect its
+/// contents. \c InputFile has a constructor that will try to figure out the file
+/// type from the file name if none is provided, but many clients that
+/// construct \c InputFile instances themselves may provide bogus file names
+/// with pre-computed kinds. It is imperative that \c InputFile::getType be used
+/// as a source of truth for this information.
+///
+/// \warning \c InputFile takes an unfortunately lax view of the ownership of
+/// its primary data. It currently only owns the file name and a copy of any
+/// assigned \c PrimarySpecificPaths outright. It is the responsibility of the
+/// caller to ensure that an associated memory buffer outlives the \c InputFile.
+class InputFile final {
   std::string Filename;
-  bool IsPrimary;
-  /// Points to a buffer overriding the file's contents, or nullptr if there is
-  /// none.
-  llvm::MemoryBuffer *Buffer;
-
-  /// If there are explicit primary inputs (i.e. designated with -primary-input
-  /// or -primary-filelist), the paths specific to those inputs (other than the
-  /// input file path itself) are kept here. If there are no explicit primary
-  /// inputs (for instance for whole module optimization), the corresponding
-  /// paths are kept in the first input file.
+  file_types::ID FileID;
+  llvm::PointerIntPair<llvm::MemoryBuffer *, 1, bool> BufferAndIsPrimary;
   PrimarySpecificPaths PSPs;
 
 public:
-  /// Does not take ownership of \p buffer. Does take ownership of (copy) a
-  /// string.
+  /// Constructs an input file from the provided data.
+  ///
+  /// \warning This entrypoint infers the type of the file from its extension
+  /// and is therefore not suitable for most clients that use files synthesized
+  /// from memory buffers. Use the overload of this constructor accepting a
+  /// memory buffer and an explicit \c file_types::ID instead.
   InputFile(StringRef name, bool isPrimary,
-            llvm::MemoryBuffer *buffer = nullptr,
-            StringRef outputFilename = StringRef())
+            llvm::MemoryBuffer *buffer = nullptr)
+      : InputFile(name, isPrimary, buffer,
+                  file_types::lookupTypeForExtension(
+                      llvm::sys::path::extension(name))) {}
+
+  /// Constructs an input file from the provided data.
+  InputFile(StringRef name, bool isPrimary, llvm::MemoryBuffer *buffer,
+            file_types::ID FileID)
       : Filename(
             convertBufferNameFromLLVM_getFileOrSTDIN_toSwiftConventions(name)),
-        IsPrimary(isPrimary), Buffer(buffer), PSPs(PrimarySpecificPaths()) {
+        FileID(FileID), BufferAndIsPrimary(buffer, isPrimary),
+        PSPs(PrimarySpecificPaths()) {
     assert(!name.empty());
   }
 
-  bool isPrimary() const { return IsPrimary; }
-  llvm::MemoryBuffer *buffer() const { return Buffer; }
-  const std::string &file() const {
+public:
+  /// Retrieves the type of this input file.
+  file_types::ID getType() const { return FileID; };
+
+  /// Retrieves whether this input file was passed as a primary to the frontend.
+  bool isPrimary() const { return BufferAndIsPrimary.getInt(); }
+
+  /// Retrieves the backing buffer for this input file, if any.
+  llvm::MemoryBuffer *getBuffer() const {
+    return BufferAndIsPrimary.getPointer();
+  }
+
+  /// The name of this \c InputFile, or `-` if this input corresponds to the
+  /// standard input stream.
+  ///
+  /// The returned file name is guaranteed not to be the empty string.
+  const std::string &getFileName() const {
     assert(!Filename.empty());
     return Filename;
   }
@@ -72,12 +98,22 @@ class InputFile {
     return filename.equals("<stdin>") ? "-" : filename;
   }
 
+  /// Retrieves the name of the output file corresponding to this input.
+  ///
+  /// If there is no such corresponding file, the result is the empty string.
+  /// If there the resulting output should be directed to the standard output
+  /// stream, the result is "-".
   std::string outputFilename() const { return PSPs.OutputFilename; }
 
+  /// If there are explicit primary inputs (i.e. designated with -primary-input
+  /// or -primary-filelist), the paths specific to those inputs (other than the
+  /// input file path itself) are kept here. If there are no explicit primary
+  /// inputs (for instance for whole module optimization), the corresponding
+  /// paths are kept in the first input file.
   const PrimarySpecificPaths &getPrimarySpecificPaths() const { return PSPs; }
 
-  void setPrimarySpecificPaths(const PrimarySpecificPaths &PSPs) {
-    this->PSPs = PSPs;
+  void setPrimarySpecificPaths(PrimarySpecificPaths &&PSPs) {
+    this->PSPs = std::move(PSPs);
   }
 
   // The next set of functions provides access to those primary-specific paths

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -143,6 +143,16 @@ bool ArgsToFrontendOptionsConverter::convert(
     Opts.InputsAndOutputs = std::move(inputsAndOutputs).getValue();
   }
 
+  if (Args.hasArg(OPT_parse_sil) || Opts.InputsAndOutputs.shouldTreatAsSIL()) {
+    Opts.InputMode = FrontendOptions::ParseInputMode::SIL;
+  } else if (Opts.InputsAndOutputs.shouldTreatAsModuleInterface()) {
+    Opts.InputMode = FrontendOptions::ParseInputMode::SwiftModuleInterface;
+  } else if (Args.hasArg(OPT_parse_as_library)) {
+    Opts.InputMode = FrontendOptions::ParseInputMode::SwiftLibrary;
+  } else {
+    Opts.InputMode = FrontendOptions::ParseInputMode::Swift;
+  }
+
   if (Opts.RequestedAction == FrontendOptions::ActionType::NoneAction) {
     Opts.RequestedAction = determineRequestedAction(Args);
   }
@@ -163,7 +173,7 @@ bool ArgsToFrontendOptionsConverter::convert(
     return true;
   }
 
-  if (setUpInputKindAndImmediateArgs())
+  if (setUpImmediateArgs())
     return true;
 
   if (computeModuleName())
@@ -398,7 +408,7 @@ ArgsToFrontendOptionsConverter::determineRequestedAction(const ArgList &args) {
   llvm_unreachable("Unhandled mode option");
 }
 
-bool ArgsToFrontendOptionsConverter::setUpInputKindAndImmediateArgs() {
+bool ArgsToFrontendOptionsConverter::setUpImmediateArgs() {
   using namespace options;
   bool treatAsSIL =
       Args.hasArg(OPT_parse_sil) || Opts.InputsAndOutputs.shouldTreatAsSIL();
@@ -419,19 +429,6 @@ bool ArgsToFrontendOptionsConverter::setUpInputKindAndImmediateArgs() {
     }
   }
 
-  if (treatAsSIL)
-    Opts.InputKind = InputFileKind::SIL;
-  else if (Opts.InputsAndOutputs.shouldTreatAsLLVM())
-    Opts.InputKind = InputFileKind::LLVM;
-  else if (Opts.InputsAndOutputs.shouldTreatAsObjCHeader())
-    Opts.InputKind = InputFileKind::ObjCHeader;
-  else if (Opts.InputsAndOutputs.shouldTreatAsModuleInterface())
-    Opts.InputKind = InputFileKind::SwiftModuleInterface;
-  else if (Args.hasArg(OPT_parse_as_library))
-    Opts.InputKind = InputFileKind::SwiftLibrary;
-  else
-    Opts.InputKind = InputFileKind::Swift;
-
   return false;
 }
 

lib/Frontend/ArgsToFrontendOptionsConverter.h

@@ -47,7 +47,7 @@ class ArgsToFrontendOptionsConverter {
   void computePrintStatsOptions();
   void computeTBDOptions();
 
-  bool setUpInputKindAndImmediateArgs();
+  bool setUpImmediateArgs();
 
   bool checkUnusedSupplementaryOutputPaths() const;
 

lib/Frontend/ArgsToFrontendOutputsConverter.cpp

@@ -183,7 +183,7 @@ OutputFilesComputer::computeOutputFile(StringRef outputArg,
 
 Optional<std::string>
 OutputFilesComputer::deriveOutputFileFromInput(const InputFile &input) const {
-  if (input.file() == "-" || HasTextualOutput)
+  if (input.getFileName() == "-" || HasTextualOutput)
     return std::string("-");
 
   std::string baseName = determineBaseNameOfOutput(input);
@@ -210,7 +210,7 @@ std::string
 OutputFilesComputer::determineBaseNameOfOutput(const InputFile &input) const {
   std::string nameToStem =
       input.isPrimary()
-          ? input.file()
+          ? input.getFileName()
           : ModuleNameArg ? ModuleNameArg->getValue() : FirstInput;
   return llvm::sys::path::stem(nameToStem).str();
 }
@@ -474,8 +474,8 @@ StringRef SupplementaryOutputPathsComputer::
   if (!outputFilename.empty() && outputFilename != "-")
     return outputFilename;
 
-  if (input.isPrimary() && input.file() != "-")
-    return llvm::sys::path::filename(input.file());
+  if (input.isPrimary() && input.getFileName() != "-")
+    return llvm::sys::path::filename(input.getFileName());
 
   return ModuleName;
 }
@@ -600,12 +600,12 @@ SupplementaryOutputPathsComputer::readSupplementaryOutputFileMap() const {
   InputsAndOutputs.forEachInputProducingSupplementaryOutput(
       [&](const InputFile &input) -> bool {
         const TypeToPathMap *mapForInput =
-            OFM->getOutputMapForInput(input.file());
+            OFM->getOutputMapForInput(input.getFileName());
         if (!mapForInput) {
           Diags.diagnose(
               SourceLoc(),
               diag::error_missing_entry_in_supplementary_output_file_map,
-              supplementaryFileMapPath, input.file());
+              supplementaryFileMapPath, input.getFileName());
           hadError = true;
         }
         outputPaths.push_back(createFromTypeToPathMap(mapForInput));