[NFC] Add type for ModuleDecl::getImplicitImports()

This doesn’t really change the design yet.

include/swift/AST/ASTTypeIDZone.def

@@ -22,7 +22,7 @@ SWIFT_TYPEID(BodyInitKindAndExpr)
 SWIFT_TYPEID(CtorInitializerKind)
 SWIFT_TYPEID(FunctionBuilderBodyPreCheck)
 SWIFT_TYPEID(GenericSignature)
-SWIFT_TYPEID(ImplicitImport)
+SWIFT_TYPEID(ImplicitImportList)
 SWIFT_TYPEID(ImplicitMemberAction)
 SWIFT_TYPEID(ParamSpecifier)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyInfo)

include/swift/AST/ASTTypeIDs.h

@@ -42,7 +42,7 @@ class GenericTypeParamType;
 class InfixOperatorDecl;
 class IterableDeclContext;
 class ModuleDecl;
-struct ImplicitImport;
+struct ImplicitImportList;
 class NamedPattern;
 class NominalTypeDecl;
 class OperatorDecl;

include/swift/AST/Import.h

@@ -565,6 +565,7 @@ enum class ImplicitStdlibKind {
   Stdlib
 };
 
+/// Represents unprocessed options for implicit imports.
 struct ImplicitImportInfo {
   /// The implicit stdlib to import.
   ImplicitStdlibKind StdlibKind;
@@ -589,6 +590,20 @@ struct ImplicitImportInfo {
         ShouldImportUnderlyingModule(false) {}
 };
 
+/// Contains names of and pointers to modules that must be implicitly imported.
+struct ImplicitImportList {
+  ArrayRef<ImplicitImport> imports;
+
+  friend bool operator==(const ImplicitImportList &lhs,
+                         const ImplicitImportList &rhs) {
+    return lhs.imports == rhs.imports;
+  }
+};
+
+/// A list of modules to implicitly import.
+void simple_display(llvm::raw_ostream &out,
+                    const ImplicitImportList &importList);
+
 }
 
 // MARK: - DenseMapInfo

include/swift/AST/Module.h

@@ -56,7 +56,6 @@ namespace swift {
   class FuncDecl;
   class InfixOperatorDecl;
   class LinkLibrary;
-  struct ImplicitImport;
   class ModuleLoader;
   class NominalTypeDecl;
   class EnumElementDecl;
@@ -278,7 +277,7 @@ public:
 
   /// Retrieve a list of modules that each file of this module implicitly
   /// imports.
-  ArrayRef<ImplicitImport> getImplicitImports() const;
+  ImplicitImportList getImplicitImports() const;
 
   ArrayRef<FileUnit *> getFiles() {
     assert(!Files.empty() || failedToLoad());

include/swift/AST/TypeCheckRequests.h

@@ -2498,7 +2498,7 @@ public:
 /// of a given module.
 class ModuleImplicitImportsRequest
     : public SimpleRequest<ModuleImplicitImportsRequest,
-                           ArrayRef<ImplicitImport>(ModuleDecl *),
+                           ImplicitImportList(ModuleDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2506,8 +2506,7 @@ public:
 private:
   friend SimpleRequest;
 
-  ArrayRef<ImplicitImport>
+  ImplicitImportList evaluate(Evaluator &evaluator, ModuleDecl *module) const;
-  evaluate(Evaluator &evaluator, ModuleDecl *module) const;
 
 public:
   // Cached.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -148,7 +148,7 @@ SWIFT_REQUEST(TypeChecker, ValidatePrecedenceGroupRequest,
 SWIFT_REQUEST(TypeChecker, MangleLocalTypeDeclRequest,
               std::string(const TypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ModuleImplicitImportsRequest,
-              ArrayRef<ImplicitImport>(ModuleDecl *), Cached, NoLocationInfo)
+              ImplicitImportList(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, NamingPatternRequest,
               NamedPattern *(VarDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, OpaqueReadOwnershipRequest,

lib/AST/Module.cpp

@@ -487,14 +487,13 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.HasIncrementalInfo = 0;
 }
 
-ArrayRef<ImplicitImport> ModuleDecl::getImplicitImports() const {
+ImplicitImportList ModuleDecl::getImplicitImports() const {
   auto &evaluator = getASTContext().evaluator;
   auto *mutableThis = const_cast<ModuleDecl *>(this);
   return evaluateOrDefault(evaluator, ModuleImplicitImportsRequest{mutableThis},
                            {});
 }
 
-
 void ModuleDecl::addFile(FileUnit &newFile) {
   // If this is a LoadedFile, make sure it loaded without error.
   assert(!(isa<LoadedFile>(newFile) &&

lib/AST/TypeCheckRequests.cpp

@@ -1397,6 +1397,14 @@ void swift::simple_display(llvm::raw_ostream &out,
   simple_display(out, import.Module);
 }
 
+void swift::simple_display(llvm::raw_ostream &out,
+                           const ImplicitImportList &importList) {
+  llvm::interleaveComma(importList.imports, out,
+                        [&](const auto &import) {
+                          simple_display(out, import);
+                        });
+}
+
 //----------------------------------------------------------------------------//
 // ResolveTypeRequest computation.
 //----------------------------------------------------------------------------//

lib/Sema/ImportResolution.cpp

@@ -174,15 +174,7 @@ public:
     addImplicitImports();
   }
 
-  void addImplicitImports() {
+  void addImplicitImports();
-    // TODO: Support cross-module imports.
-    for (auto &import : SF.getParentModule()->getImplicitImports()) {
-      assert(!(SF.Kind == SourceFileKind::SIL &&
-               import.Module->isStdlibModule()));
-      ImportedModule importedMod{ImportPath::Access(), import.Module};
-      boundImports.emplace_back(importedMod, import.Options);
-    }
-  }
 
   /// Retrieve the finalized imports.
   ArrayRef<AttributedImport<ImportedModule>> getFinishedImports() const {
@@ -400,7 +392,7 @@ UnboundImport::getTopLevelModule(ModuleDecl *M, SourceFile &SF) {
 // MARK: Implicit imports
 //===----------------------------------------------------------------------===//
 
-ArrayRef<ImplicitImport>
+ImplicitImportList
 ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
                                        ModuleDecl *module) const {
   SmallVector<ImplicitImport, 4> imports;
@@ -468,7 +460,19 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
     }
   }
 
-  return ctx.AllocateCopy(imports);
+  return { ctx.AllocateCopy(imports) };
+}
+
+void ImportResolver::addImplicitImports() {
+  auto implicitImports = SF.getParentModule()->getImplicitImports();
+
+  // 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);
+  }
 }
 
 //===----------------------------------------------------------------------===//