[NFC] Eliminate ImplicitImport

Instead, we will use AttributedImport<ImportedModule>, a common currency type which supports a superset of ImplicitImport’s current behavior.

Author: beccadax

include/swift/AST/Import.h

@@ -532,26 +532,21 @@ struct AttributedImport {
              options.contains(ImportFlags::ImplementationOnly)) ||
            options.contains(ImportFlags::Reserved));
   }
-};
-
-// MARK: - Implicit imports
-
-/// A module which has been implicitly imported.
-struct ImplicitImport {
-  ModuleDecl *Module;
-  ImportOptions Options;
 
-  ImplicitImport(ModuleDecl *module, ImportOptions opts = {})
-      : Module(module), Options(opts) {}
-
-  friend bool operator==(const ImplicitImport &lhs,
-                         const ImplicitImport &rhs) {
-    return lhs.Module == rhs.Module &&
-           lhs.Options.toRaw() == rhs.Options.toRaw();
+  friend bool operator==(const AttributedImport<ModuleInfo> &lhs,
+                         const AttributedImport<ModuleInfo> &rhs) {
+    return lhs.module == rhs.module &&
+           lhs.options.toRaw() == rhs.options.toRaw() &&
+           lhs.sourceFileArg == rhs.sourceFileArg &&
+           lhs.spiGroups == rhs.spiGroups;
   }
 };
 
-void simple_display(llvm::raw_ostream &out, const ImplicitImport &import);
+/// A module which has been implicitly imported.
+void simple_display(llvm::raw_ostream &out,
+                    const AttributedImport<ImportedModule> &import);
+
+// MARK: - Implicit imports
 
 /// The kind of stdlib that should be imported.
 enum class ImplicitStdlibKind {
@@ -592,7 +587,7 @@ struct ImplicitImportInfo {
 
 /// Contains names of and pointers to modules that must be implicitly imported.
 struct ImplicitImportList {
-  ArrayRef<ImplicitImport> imports;
+  ArrayRef<AttributedImport<ImportedModule>> imports;
 
   friend bool operator==(const ImplicitImportList &lhs,
                          const ImplicitImportList &rhs) {

lib/AST/TypeCheckRequests.cpp

@@ -1392,9 +1392,37 @@ TypeCheckFunctionBodyRequest::readDependencySource(
 //----------------------------------------------------------------------------//
 
 void swift::simple_display(llvm::raw_ostream &out,
-                           const ImplicitImport &import) {
-  out << "implicit import of ";
-  simple_display(out, import.Module);
+                           const AttributedImport<ImportedModule> &import) {
+  out << "import of ";
+
+  if (!import.module.accessPath.empty()) {
+    simple_display(out, import.module.accessPath.front().Item);
+    out << " in ";
+  }
+
+  simple_display(out, import.module.importedModule);
+
+  out << " [";
+  if (import.options.contains(ImportFlags::Exported))
+    out << " exported";
+  if (import.options.contains(ImportFlags::Testable))
+    out << " testable";
+  if (import.options.contains(ImportFlags::ImplementationOnly))
+    out << " implementation-only";
+  if (import.options.contains(ImportFlags::PrivateImport))
+    out << " private(" << import.sourceFileArg << ")";
+
+  if (import.options.contains(ImportFlags::SPIAccessControl)) {
+    out << " spi(";
+    llvm::interleave(import.spiGroups,
+                     [&out](Identifier name) {
+                       simple_display(out, name);
+                     },
+                     [&out]() { out << " "; });
+    out << ")";
+  }
+
+  out << " ]";
 }
 
 void swift::simple_display(llvm::raw_ostream &out,

lib/Sema/ImportResolution.cpp

@@ -395,26 +395,32 @@ UnboundImport::getTopLevelModule(ModuleDecl *M, SourceFile &SF) {
 ImplicitImportList
 ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
                                        ModuleDecl *module) const {
-  SmallVector<ImplicitImport, 4> imports;
+  SmallVector<AttributedImport<ImportedModule>, 4> imports;
 
   auto &ctx = module->getASTContext();
   auto &importInfo = module->getImplicitImportInfo();
 
   // Add an implicit stdlib if needed.
+  ModuleDecl *stdlib;
   switch (importInfo.StdlibKind) {
   case ImplicitStdlibKind::None:
+    stdlib = nullptr;
     break;
   case ImplicitStdlibKind::Builtin:
-    imports.emplace_back(ctx.TheBuiltinModule);
+    stdlib = ctx.TheBuiltinModule;
     break;
   case ImplicitStdlibKind::Stdlib: {
-    auto *stdlib = ctx.getStdlibModule(/*loadIfAbsent*/ true);
+    stdlib = ctx.getStdlibModule(/*loadIfAbsent*/ true);
     assert(stdlib && "Missing stdlib?");
-    imports.emplace_back(stdlib);
     break;
   }
   }
 
+  if (stdlib) {
+    ImportedModule import(ImportPath::Access(), stdlib);
+    imports.emplace_back(import, ImportOptions());
+  }
+
   // Add any modules we were asked to implicitly import.
   for (auto moduleName : importInfo.ModuleNames) {
     auto *importModule = ctx.getModuleByIdentifier(moduleName);
@@ -427,13 +433,15 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
       }
       continue;
     }
-    imports.emplace_back(importModule);
+    ImportedModule import(ImportPath::Access(), importModule);
+    imports.emplace_back(import, ImportOptions());
   }
 
   // Add any pre-loaded modules.
   for (auto &module : importInfo.AdditionalModules) {
-    imports.emplace_back(module.first, module.second ? ImportFlags::Exported
-                                                     : ImportOptions());
+    ImportedModule import(ImportPath::Access(), module.first);
+    imports.emplace_back(import, module.second ? ImportFlags::Exported
+                                               : ImportOptions());
   }
 
   auto *clangImporter =
@@ -445,15 +453,17 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
       !clangImporter->importBridgingHeader(bridgingHeaderPath, module)) {
     auto *headerModule = clangImporter->getImportedHeaderModule();
     assert(headerModule && "Didn't load bridging header?");
-    imports.emplace_back(headerModule, ImportFlags::Exported);
+    ImportedModule import(ImportPath::Access(), headerModule);
+    imports.emplace_back(import, ImportFlags::Exported);
   }
 
   // Implicitly import the underlying Clang half of this module if needed.
   if (importInfo.ShouldImportUnderlyingModule) {
     auto *underlyingMod = clangImporter->loadModule(
         SourceLoc(), ImportPath::Module::Builder(module->getName()).get());
     if (underlyingMod) {
-      imports.emplace_back(underlyingMod, ImportFlags::Exported);
+      ImportedModule import(ImportPath::Access(), underlyingMod);
+      imports.emplace_back(import, ImportFlags::Exported);
     } else {
       ctx.Diags.diagnose(SourceLoc(), diag::error_underlying_module_not_found,
                          module->getName());
@@ -469,9 +479,8 @@ void ImportResolver::addImplicitImports() {
   // TODO: Support cross-module imports.
   for (auto &import : implicitImports.imports) {
     assert(!(SF.Kind == SourceFileKind::SIL &&
-             import.Module->isStdlibModule()));
-    ImportedModule importedMod{ImportPath::Access(), import.Module};
-    boundImports.emplace_back(importedMod, import.Options);
+             import.module.importedModule->isStdlibModule()));
+    boundImports.push_back(import);
   }
 }