[NFC] Add conveniences to clean up import code

Author: beccadax

include/swift/AST/Import.h

@@ -28,6 +28,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 namespace swift {
@@ -151,6 +152,17 @@ namespace detail {
       if (empty()) return SourceRange();
       return SourceRange(raw.front().Loc, raw.back().Loc);
     }
+
+    void print(llvm::raw_ostream &os) const {
+      llvm::interleave(*this,
+                       [&](Element elem) { os << elem.Item.str(); },
+                       [&]() { os << "."; });
+    }
+
+    void getString(SmallVectorImpl<char> &modulePathStr) const {
+      llvm::raw_svector_ostream os(modulePathStr);
+      print(os);
+    }
   };
 
   // These shims avoid circularity between ASTContext.h and Import.h.
@@ -479,6 +491,9 @@ struct alignas(uint64_t) ImportedModule {
     assert(this->importedModule);
   }
 
+  explicit ImportedModule(ModuleDecl *importedModule)
+      : ImportedModule(ImportPath::Access(), importedModule) { }
+
   bool operator==(const ImportedModule &other) const {
     return (this->importedModule == other.importedModule) &&
            (this->accessPath == other.accessPath);
@@ -490,6 +505,10 @@ struct alignas(uint64_t) ImportedModule {
   /// The order of items in \p imports is \e not preserved.
   static void removeDuplicates(SmallVectorImpl<ImportedModule> &imports);
 
+  // Purely here to allow ImportedModule and UnloadedImportedModule to
+  // substitute into the same templates.
+  ImportPath::Access getAccessPath() const { return accessPath; }
+
   /// Arbitrarily orders ImportedModule records, for inclusion in sets and such.
   class Order {
   public:
@@ -524,7 +543,7 @@ struct AttributedImport {
   /// Names of explicitly imported SPI groups.
   ArrayRef<Identifier> spiGroups;
 
-  AttributedImport(ModuleInfo module, ImportOptions options,
+  AttributedImport(ModuleInfo module, ImportOptions options = ImportOptions(),
                    StringRef filename = {}, ArrayRef<Identifier> spiGroups = {})
       : module(module), options(options), sourceFileArg(filename),
         spiGroups(spiGroups) {
@@ -533,13 +552,22 @@ struct AttributedImport {
            options.contains(ImportFlags::Reserved));
   }
 
+  template<class OtherModuleInfo>
+  AttributedImport(ModuleInfo module, AttributedImport<OtherModuleInfo> other)
+    : AttributedImport(module, other.options, other.sourceFileArg,
+                       other.spiGroups) { }
+
   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;
   }
+
+  AttributedImport<ImportedModule> getLoaded(ModuleDecl *loadedModule) const {
+    return { ImportedModule(module.getAccessPath(), loadedModule), *this };
+  }
 };
 
 /// A module which has been implicitly imported.

include/swift/AST/ModuleDependencies.h

@@ -19,6 +19,7 @@
 #define SWIFT_AST_MODULE_DEPENDENCIES_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/AST/Import.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSet.h"
@@ -330,6 +331,12 @@ class ModuleDependencies {
   void addModuleDependency(StringRef module,
                            llvm::StringSet<> *alreadyAddedModules = nullptr);
 
+  /// Add a dependency on the given module, if it was not already in the set.
+  void addModuleDependency(ImportPath::Module module,
+                           llvm::StringSet<> *alreadyAddedModules = nullptr) {
+    addModuleDependency(module.front().Item.str(), alreadyAddedModules);
+  }
+
   /// Add all of the module dependencies for the imports in the given source
   /// file to the set of module dependencies.
   void addModuleDependencies(const SourceFile &sf,

lib/AST/ASTDumper.cpp

@@ -620,11 +620,7 @@ namespace {
         OS << " kind=" << getImportKindString(ID->getImportKind());
 
       OS << " '";
-      llvm::interleave(ID->getImportPath(),
-                       [&](const ImportPath::Element &Elem) {
-                         OS << Elem.Item;
-                       },
-                       [&] { OS << '.'; });
+      ID->getImportPath().print(OS);
       OS << "')";
     }
 

lib/AST/ModuleDependencies.cpp

@@ -62,8 +62,7 @@ void ModuleDependencies::addModuleDependencies(
     if (!importDecl)
       continue;
 
-    addModuleDependency(importDecl->getModulePath().front().Item.str(),
-                        &alreadyAddedModules);
+    addModuleDependency(importDecl->getModulePath(), &alreadyAddedModules);
   }
 
   auto fileName = sf.getFilename();

lib/AST/ModuleNameLookup.cpp

@@ -202,8 +202,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
       if (auto *loader = ctx.getClangModuleLoader()) {
         headerImportModule = loader->getImportedHeaderModule();
         if (headerImportModule) {
-          ImportedModule import{ImportPath::Access(), headerImportModule};
-          visitImport(import, nullptr);
+          visitImport(ImportedModule(headerImportModule), nullptr);
         }
       }
     }

lib/AST/TypeCheckRequests.cpp

@@ -1395,14 +1395,14 @@ void swift::simple_display(llvm::raw_ostream &out,
                            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.module.accessPath.empty()) {
+    out << " scoped(";
+    import.module.accessPath.print(out);
+    out << ")";
+  }
   if (import.options.contains(ImportFlags::Exported))
     out << " exported";
   if (import.options.contains(ImportFlags::Testable))
@@ -1414,11 +1414,9 @@ void swift::simple_display(llvm::raw_ostream &out,
 
   if (import.options.contains(ImportFlags::SPIAccessControl)) {
     out << " spi(";
-    llvm::interleave(import.spiGroups,
-                     [&out](Identifier name) {
-                       simple_display(out, name);
-                     },
-                     [&out]() { out << " "; });
+    llvm::interleaveComma(import.spiGroups, out, [&out](Identifier name) {
+                                                   simple_display(out, name);
+                                                 });
     out << ")";
   }
 

lib/FrontendTool/ScanDependencies.cpp

@@ -818,7 +818,7 @@ bool swift::scanDependencies(CompilerInstance &instance) {
 
     // Add any implicit module names.
     for (const auto &import : importInfo.AdditionalUnloadedImports) {
-      mainDependencies.addModuleDependency(import.module.getModulePath().front().Item.str(), &alreadyAddedModules);
+      mainDependencies.addModuleDependency(import.module.getModulePath(), &alreadyAddedModules);
     }
 
     // Already-loaded, implicitly imported module names.

lib/IDE/REPLCodeCompletion.cpp

@@ -221,17 +221,14 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
   auto *lastModule = SF.getParentModule();
 
   ImplicitImportInfo implicitImports;
-  {
-    ImportedModule import(ImportPath::Access(), lastModule);
-    implicitImports.AdditionalImports.emplace_back(import, ImportOptions());
-  }
+  implicitImports.AdditionalImports.emplace_back(ImportedModule(lastModule));
 
   // Carry over the private imports from the last module.
   SmallVector<ImportedModule, 8> imports;
   lastModule->getImportedModules(imports,
                                  ModuleDecl::ImportFilterKind::Default);
   for (auto &import : imports) {
-    implicitImports.AdditionalImports.emplace_back(import, ImportOptions());
+    implicitImports.AdditionalImports.emplace_back(import);
   }
 
   // Create a new module and file for the code completion buffer, similar to how

lib/Sema/ImportResolution.cpp

@@ -118,8 +118,7 @@ struct UnboundImport {
   /// UnboundImport.
   AttributedImport<ImportedModule>
   makeAttributedImport(ModuleDecl *module) const {
-    return { ImportedModule{ import.module.getAccessPath(), module },
-             import.options, import.sourceFileArg, import.spiGroups };
+    return import.getLoaded(module);
   }
 
 private:
@@ -396,10 +395,7 @@ static void diagnoseNoSuchModule(ASTContext &ctx, SourceLoc importLoc,
                                  ImportPath::Module modulePath,
                                  bool nonfatalInREPL) {
   SmallString<64> modulePathStr;
-  llvm::interleave(modulePath, [&](ImportPath::Element elem) {
-                     modulePathStr += elem.Item.str();
-                   },
-                   [&] { modulePathStr += "."; });
+  modulePath.getString(modulePathStr);
 
   auto diagKind = diag::sema_no_import;
   if (nonfatalInREPL && ctx.LangOpts.DebuggerSupport)
@@ -430,17 +426,14 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
   case ImplicitStdlibKind::Builtin:
     stdlib = ctx.TheBuiltinModule;
     break;
-  case ImplicitStdlibKind::Stdlib: {
+  case ImplicitStdlibKind::Stdlib:
     stdlib = ctx.getStdlibModule(/*loadIfAbsent*/ true);
     assert(stdlib && "Missing stdlib?");
     break;
   }
-  }
 
-  if (stdlib) {
-    ImportedModule import(ImportPath::Access(), stdlib);
-    imports.emplace_back(import, ImportOptions());
-  }
+  if (stdlib)
+    imports.emplace_back(ImportedModule(stdlib));
 
   // Add any modules we were asked to implicitly import.
   for (auto unloadedImport : importInfo.AdditionalUnloadedImports) {
@@ -451,10 +444,7 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
                            /*nonfatalInREPL=*/false);
       continue;
     }
-    ImportedModule import(unloadedImport.module.getAccessPath(), importModule);
-    imports.emplace_back(import, unloadedImport.options,
-                         unloadedImport.sourceFileArg,
-                         unloadedImport.spiGroups);
+    imports.push_back(unloadedImport.getLoaded(importModule));
   }
 
   // Add any pre-loaded modules.
@@ -469,17 +459,16 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
       !clangImporter->importBridgingHeader(bridgingHeaderPath, module)) {
     auto *headerModule = clangImporter->getImportedHeaderModule();
     assert(headerModule && "Didn't load bridging header?");
-    ImportedModule import(ImportPath::Access(), headerModule);
-    imports.emplace_back(import, ImportFlags::Exported);
+    imports.emplace_back(ImportedModule(headerModule), 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) {
-      ImportedModule import(ImportPath::Access(), underlyingMod);
-      imports.emplace_back(import, ImportFlags::Exported);
+      imports.emplace_back(ImportedModule(underlyingMod),
+                           ImportFlags::Exported);
     } else {
       ctx.Diags.diagnose(SourceLoc(), diag::error_underlying_module_not_found,
                          module->getName());

lib/Serialization/ModuleDependencyScanner.cpp

@@ -150,7 +150,7 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
     // printed in the interface file, e.g. SwiftOnoneSupport.
     auto &imInfo = mainMod->getImplicitImportInfo();
     for (auto import: imInfo.AdditionalUnloadedImports) {
-      Result->addModuleDependency(import.module.getModulePath().front().Item.str(), &alreadyAddedModules);
+      Result->addModuleDependency(import.module.getModulePath(), &alreadyAddedModules);
     }
     return std::error_code();
   });