[CodeCompletion] Complete Swift only module name after 'import'

rintaro · rintaro · commit 6956089b0bb9 · 2019-05-08T10:11:52.000-07:00
rdar://problem/39392446
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -860,6 +860,10 @@ class ASTContext final {
   /// not necessarily loaded.
   void getVisibleTopLevelClangModules(SmallVectorImpl<clang::Module*> &Modules) const;
 
+  /// Populate \p names with visible top level module names.
+  /// This guarantees that resulted \p names doesn't have duplicated names.
+  void getVisibleTopLevelModuleNames(SmallVectorImpl<Identifier> &names) const;
+
 private:
   /// Register the given generic signature builder to be used as the canonical
   /// generic signature builder for the given signature, if we don't already
diff --git a/include/swift/AST/ModuleLoader.h b/include/swift/AST/ModuleLoader.h
@@ -82,6 +82,13 @@ class ModuleLoader {
 public:
   virtual ~ModuleLoader() = default;
 
+  /// Collect visible module names.
+  ///
+  /// Append visible module names to \p names. Note that names are possibly
+  /// duplicated, and not guaranteed to be ordered in any way.
+  virtual void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const = 0;
+
   /// Check whether the module with a given name can be imported without
   /// importing it.
   ///
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
@@ -119,6 +119,11 @@ class ClangImporter final : public ClangModuleLoader {
   static std::shared_ptr<clang::DependencyCollector>
   createDependencyCollector(bool TrackSystemDeps);
 
+  /// Append visible module names to \p names. Note that names are possibly
+  /// duplicated, and not guaranteed to be ordered in any way.
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override;
+
   /// Check whether the module with a given name can be imported without
   /// importing it.
   ///
@@ -336,7 +341,7 @@ class ClangImporter final : public ClangModuleLoader {
   /// Calling this function does not load the module.
   void collectSubModuleNames(
       ArrayRef<std::pair<Identifier, SourceLoc>> path,
-      std::vector<std::string> &names);
+      std::vector<std::string> &names) const;
 
   /// Given a Clang module, decide whether this module is imported already.
   static bool isModuleImported(const clang::Module *M);
diff --git a/include/swift/DWARFImporter/DWARFImporter.h b/include/swift/DWARFImporter/DWARFImporter.h
@@ -66,6 +66,9 @@ class DWARFImporter final : public ClangModuleLoader {
 
   ~DWARFImporter();
 
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override;
+
   /// Check whether the module with a given name can be imported without
   /// importing it.
   ///
diff --git a/include/swift/Frontend/ParseableInterfaceModuleLoader.h b/include/swift/Frontend/ParseableInterfaceModuleLoader.h
@@ -154,6 +154,11 @@ class ParseableInterfaceModuleLoader : public SerializedModuleLoaderBase {
                                          RemarkOnRebuildFromInterface));
   }
 
+  /// Append visible module names to \p names. Note that names are possibly
+  /// duplicated, and not guaranteed to be ordered in any way.
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override;
+
   /// Unconditionally build \p InPath (a swiftinterface file) to \p OutPath (as
   /// a swiftmodule file).
   ///
diff --git a/include/swift/Sema/SourceLoader.h b/include/swift/Sema/SourceLoader.h
@@ -48,6 +48,11 @@ class SourceLoader : public ModuleLoader {
   SourceLoader &operator=(const SourceLoader &) = delete;
   SourceLoader &operator=(SourceLoader &&) = delete;
 
+  /// Append visible module names to \p names. Note that names are possibly
+  /// duplicated, and not guaranteed to be ordered in any way.
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override;
+
   /// Check whether the module with a given name can be imported without
   /// importing it.
   ///
diff --git a/include/swift/Serialization/SerializedModuleLoader.h b/include/swift/Serialization/SerializedModuleLoader.h
@@ -44,6 +44,9 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   SerializedModuleLoaderBase(ASTContext &ctx, DependencyTracker *tracker,
                              ModuleLoadingMode LoadMode);
 
+  void collectVisibleTopLevelModuleNamesImpl(SmallVectorImpl<Identifier> &names,
+                                             StringRef extension) const;
+
   using AccessPathElem = std::pair<Identifier, SourceLoc>;
   bool findModule(AccessPathElem moduleID,
                   std::unique_ptr<llvm::MemoryBuffer> *moduleBuffer,
@@ -169,6 +172,11 @@ class SerializedModuleLoader : public SerializedModuleLoaderBase {
 public:
   virtual ~SerializedModuleLoader();
 
+  /// Append visible module names to \p names. Note that names are possibly
+  /// duplicated, and not guaranteed to be ordered in any way.
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override;
+
   /// Create a new importer that can load serialized Swift modules
   /// into the given ASTContext.
   static std::unique_ptr<SerializedModuleLoader>
@@ -220,6 +228,9 @@ class MemoryBufferSerializedModuleLoader : public SerializedModuleLoaderBase {
     MemoryBuffers[AccessPath] = std::move(input);
   }
 
+  void collectVisibleTopLevelModuleNames(
+      SmallVectorImpl<Identifier> &names) const override {}
+
   /// Create a new importer that can load serialized Swift modules
   /// into the given ASTContext.
   static std::unique_ptr<MemoryBufferSerializedModuleLoader>
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -1670,6 +1670,19 @@ void ProtocolDecl::setDefaultAssociatedConformanceWitness(
   (void)pair;
 }
 
+void ASTContext::getVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {
+  names.clear();
+  for (auto &importer : getImpl().ModuleLoaders)
+    importer->collectVisibleTopLevelModuleNames(names);
+
+  // Sort and unique.
+  std::sort(names.begin(), names.end(), [](Identifier LHS, Identifier RHS) {
+    return LHS.str().compare_lower(RHS.str()) < 0;
+  });
+  names.erase(std::unique(names.begin(), names.end()), names.end());
+}
+
 bool ASTContext::canImportModule(std::pair<Identifier, SourceLoc> ModulePath) {
   // If this module has already been successfully imported, it is importable.
   if (getLoadedModule(ModulePath) != nullptr)
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -1494,9 +1494,22 @@ ClangImporter::emitBridgingPCH(StringRef headerPath,
   return false;
 }
 
+void ClangImporter::collectVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {
+  SmallVector<clang::Module *, 32> Modules;
+  Impl.getClangPreprocessor().getHeaderSearchInfo().collectAllModules(Modules);
+  for (auto &M : Modules) {
+    if (!M->isAvailable())
+      continue;
+
+    names.push_back(
+        Impl.SwiftContext.getIdentifier(M->getTopLevelModuleName()));
+  }
+}
+
 void ClangImporter::collectSubModuleNames(
     ArrayRef<std::pair<Identifier, SourceLoc>> path,
-    std::vector<std::string> &names) {
+    std::vector<std::string> &names) const {
   auto &clangHeaderSearch = Impl.getClangPreprocessor().getHeaderSearchInfo();
 
   // Look up the top-level module first.
diff --git a/lib/DWARFImporter/DWARFImporter.cpp b/lib/DWARFImporter/DWARFImporter.cpp
@@ -142,6 +142,9 @@ DWARFImporter::DWARFImporter(ASTContext &ctx,
 
 DWARFImporter::~DWARFImporter() { delete &Impl; }
 
+void DWARFImporter::collectVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {}
+
 bool DWARFImporter::canImportModule(std::pair<Identifier, SourceLoc> named) {
   return false;
 }
diff --git a/lib/Frontend/ParseableInterfaceModuleLoader.cpp b/lib/Frontend/ParseableInterfaceModuleLoader.cpp
@@ -1377,3 +1377,10 @@ bool ParseableInterfaceModuleLoader::buildSwiftModuleFromSwiftInterface(
   return builder.buildSwiftModule(OutPath, /*shouldSerializeDeps*/true,
                                   /*ModuleBuffer*/nullptr);
 }
+
+void ParseableInterfaceModuleLoader::collectVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {
+  collectVisibleTopLevelModuleNamesImpl(
+      names,
+      file_types::getExtension(file_types::TY_SwiftParseableInterfaceFile));
+}
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -1753,35 +1753,22 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   }
 
   void addImportModuleNames() {
-    // FIXME: Add user-defined swift modules
-    SmallVector<StringRef, 20> ModuleNames;
-
-    // Collect clang module names.
-    {
-      SmallVector<clang::Module*, 20> ClangModules;
-      Ctx.getVisibleTopLevelClangModules(ClangModules);
-      for (auto *M : ClangModules) {
-        if (!M->isAvailable())
-          continue;
-        if (M->getTopLevelModuleName().startswith("_"))
-          continue;
-        if (M->getTopLevelModuleName() == Ctx.SwiftShimsModuleName.str())
-          continue;
-
-        ModuleNames.push_back(M->getTopLevelModuleName());
-      }
-    }
-
-    std::sort(ModuleNames.begin(), ModuleNames.end(),
-              [](StringRef LHS, StringRef RHS) {
-                return LHS.compare_lower(RHS) < 0;
-              });
+    SmallVector<Identifier, 0> ModuleNames;
+    Ctx.getVisibleTopLevelModuleNames(ModuleNames);
 
     llvm::StringSet<> ImportedModules;
     collectImportedModules(ImportedModules);
 
+    auto mainModuleName = CurrDeclContext->getParentModule()->getName();
     for (auto ModuleName : ModuleNames) {
-      auto MD = ModuleDecl::create(Ctx.getIdentifier(ModuleName), Ctx);
+      if (ModuleName == mainModuleName)
+        continue;
+      if (ModuleName.str().startswith("_"))
+        continue;
+      if (ModuleName == Ctx.SwiftShimsModuleName)
+        continue;
+
+      auto MD = ModuleDecl::create(ModuleName, Ctx);
       CodeCompletionResultBuilder Builder(
           Sink,
           CodeCompletionResult::ResultKind::Declaration,
diff --git a/lib/Sema/SourceLoader.cpp b/lib/Sema/SourceLoader.cpp
@@ -70,6 +70,11 @@ class SkipNonTransparentFunctions : public DelayedParsingCallbacks {
 
 } // unnamed namespace
 
+void SourceLoader::collectVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {
+  // TODO: Implement?
+}
+
 bool SourceLoader::canImportModule(std::pair<Identifier, SourceLoc> ID) {
   // Search the memory buffers to see if we can find this file on disk.
   FileOrError inputFileOrError = findModule(Ctx, ID.first.str(),
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
@@ -44,6 +44,149 @@ SerializedModuleLoader::~SerializedModuleLoader() = default;
 MemoryBufferSerializedModuleLoader::~MemoryBufferSerializedModuleLoader() =
     default;
 
+void SerializedModuleLoaderBase::collectVisibleTopLevelModuleNamesImpl(
+    SmallVectorImpl<Identifier> &names, StringRef extension) const {
+  llvm::SmallString<16> moduleSuffix;
+  moduleSuffix += '.';
+  moduleSuffix += file_types::getExtension(file_types::TY_SwiftModuleFile);
+
+  llvm::SmallString<16> suffix;
+  suffix += '.';
+  suffix += extension;
+
+  SmallVector<SmallString<64>, 3> targetFiles;
+  targetFiles.emplace_back(
+      getTargetSpecificModuleTriple(Ctx.LangOpts.Target).str());
+  targetFiles.back() += suffix;
+  targetFiles.emplace_back(Ctx.LangOpts.Target.getArchName());
+  targetFiles.back() += suffix;
+
+  auto &fs = *Ctx.SourceMgr.getFileSystem();
+
+  // Apply \p body for each directory entry in \p dirPath.
+  auto forEachDirectoryEntryPath =
+      [&](StringRef dirPath, llvm::function_ref<void(StringRef)> body) {
+        std::error_code errorCode;
+        llvm::vfs::directory_iterator DI = fs.dir_begin(dirPath, errorCode);
+        llvm::vfs::directory_iterator End;
+        for (; !errorCode && DI != End; DI.increment(errorCode))
+          body(DI->path());
+      };
+
+  // Check whether target specific module file exists or not in given directory.
+  // $PATH/{arch}.{extension}
+  auto checkTargetFiles = [&](StringRef path) -> bool {
+    llvm::SmallString<256> scratch;
+    for (auto targetFile : targetFiles) {
+      scratch.clear();
+      llvm::sys::path::append(scratch, path, targetFile);
+      // If {arch}.{extension} exists, consider it's visible. Technically, we
+      // should check the file type, permission, format, etc., but it's too
+      // heavy to do that for each files.
+      if (fs.exists(scratch))
+        return true;
+    }
+    return false;
+  };
+
+  auto tryImportSearchPath = [&](StringRef searchPath) {
+    // Look for:
+    // $PATH/{name}.swiftmodule/{arch}.{extension} ; Or
+    // $PATH/{name}.{extension}
+    forEachDirectoryEntryPath(searchPath, [&](StringRef path) {
+      auto pathExt = llvm::sys::path::extension(path);
+      if (pathExt != moduleSuffix && pathExt != suffix)
+        return;
+
+      auto stat = fs.status(path);
+      if (!stat)
+        return;
+      if (pathExt == moduleSuffix && stat->isDirectory()) {
+        if (!checkTargetFiles(path))
+          return;
+      } else if (pathExt != suffix) {
+        return;
+      }
+      // Extract module name.
+      auto name = llvm::sys::path::filename(path).drop_back(pathExt.size());
+      names.push_back(Ctx.getIdentifier(name));
+    });
+  };
+
+  auto tryRuntimeLibraryPath = [&](StringRef searchPath) {
+    // Look for:
+    // (Darwin OS) $PATH/{name}.swiftmodule/{arch}.{extension}
+    // (Other OS)  $PATH/{name}.{extension}
+    bool requireTargetSpecificModule = Ctx.LangOpts.Target.isOSDarwin();
+    forEachDirectoryEntryPath(searchPath, [&](StringRef path) {
+      auto pathExt = llvm::sys::path::extension(path);
+      if (requireTargetSpecificModule) {
+        if (pathExt != moduleSuffix)
+          return;
+        if (!checkTargetFiles(path))
+          return;
+      } else {
+        auto stat = fs.status(path);
+        if (!stat || stat->isDirectory())
+          return;
+        if (suffix != pathExt)
+          return;
+      }
+      // Extract module name.
+      auto name = llvm::sys::path::filename(path).drop_back(pathExt.size());
+      names.push_back(Ctx.getIdentifier(name));
+    });
+  };
+
+  auto tryFrameworkSearchPath = [&](StringRef searchPath) {
+    // Look for:
+    // $PATH/{name}.framework/Modules/{name}.swiftmodule/{arch}.{extension}
+    forEachDirectoryEntryPath(searchPath, [&](StringRef path) {
+      if (llvm::sys::path::extension(path) != ".framework")
+        return;
+
+      // Extract Framework name.
+      auto name = llvm::sys::path::filename(path).drop_back(
+          StringLiteral(".framework").size());
+
+      SmallString<128> moduleDir;
+      llvm::sys::path::append(moduleDir, path, "Modules", name + moduleSuffix);
+      if (!checkTargetFiles(moduleDir))
+        return;
+
+      names.push_back(Ctx.getIdentifier(name));
+    });
+  };
+
+  for (const auto &path : Ctx.SearchPathOpts.ImportSearchPaths)
+    tryImportSearchPath(path);
+
+  for (const auto &path : Ctx.SearchPathOpts.FrameworkSearchPaths)
+    tryFrameworkSearchPath(path.Path);
+
+  // Apple platforms have extra implicit framework search paths:
+  // $SDKROOT/System/Library/Frameworks/ and $SDKROOT/Library/Frameworks/
+  if (Ctx.LangOpts.Target.isOSDarwin()) {
+    SmallString<128> scratch;
+    scratch = Ctx.SearchPathOpts.SDKPath;
+    llvm::sys::path::append(scratch, "System", "Library", "Frameworks");
+    tryFrameworkSearchPath(scratch);
+
+    scratch = Ctx.SearchPathOpts.SDKPath;
+    llvm::sys::path::append(scratch, "Library", "Frameworks");
+    tryFrameworkSearchPath(scratch);
+  }
+
+  for (auto importPath : Ctx.SearchPathOpts.RuntimeLibraryImportPaths)
+    tryRuntimeLibraryPath(importPath);
+}
+
+void SerializedModuleLoader::collectVisibleTopLevelModuleNames(
+    SmallVectorImpl<Identifier> &names) const {
+  collectVisibleTopLevelModuleNamesImpl(
+      names, file_types::getExtension(file_types::TY_SwiftModuleFile));
+}
+
 std::error_code SerializedModuleLoaderBase::openModuleDocFile(
   AccessPathElem ModuleID, StringRef ModuleDocPath,
   std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer) {

Original file line number	Diff line number	Diff line change
`@@ -142,6 +142,9 @@ DWARFImporter::DWARFImporter(ASTContext &ctx,`
`142`	`142`
`143`	`143`	`DWARFImporter::~DWARFImporter() { delete &Impl; }`
`144`	`144`
	`145`	`+void DWARFImporter::collectVisibleTopLevelModuleNames(`
	`146`	`+ SmallVectorImpl<Identifier> &names) const {}`
	`147`	`+`
`145`	`148`	`bool DWARFImporter::canImportModule(std::pair<Identifier, SourceLoc> named) {`
`146`	`149`	`return false;`
`147`	`150`	`}`