[NFC] Adopt new ImportPath types and terminology

# Conflicts:
#	lib/IDE/CodeCompletion.cpp

Author: beccadax

include/swift/AST/ASTContext.h

@@ -20,6 +20,7 @@
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/Import.h"
 #include "swift/AST/SearchPathOptions.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
@@ -859,12 +860,12 @@ class ASTContext final {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  bool canImportModule(Located<Identifier> ModulePath);
+  bool canImportModule(ImportPath::Element ModulePath);
 
   /// \returns a module with a given name that was already loaded.  If the
   /// module was not loaded, returns nullptr.
   ModuleDecl *getLoadedModule(
-      ArrayRef<Located<Identifier>> ModulePath) const;
+      ImportPath::Module ModulePath) const;
 
   ModuleDecl *getLoadedModule(Identifier ModuleName) const;
 
@@ -874,7 +875,7 @@ class ASTContext final {
   /// be returned.
   ///
   /// \returns The requested module, or NULL if the module cannot be found.
-  ModuleDecl *getModule(ArrayRef<Located<Identifier>> ModulePath);
+  ModuleDecl *getModule(ImportPath::Module ModulePath);
 
   ModuleDecl *getModuleByName(StringRef ModuleName);
 

include/swift/AST/Decl.h

@@ -1461,11 +1461,12 @@ static_assert(sizeof(_GenericContext) + sizeof(DeclContext) ==
 ///   import Swift
 ///   import typealias Swift.Int
 class ImportDecl final : public Decl,
-    private llvm::TrailingObjects<ImportDecl, Located<Identifier>> {
+    private llvm::TrailingObjects<ImportDecl, ImportPath::Element> {
   friend TrailingObjects;
   friend class Decl;
 public:
-  typedef Located<Identifier> AccessPathElement;
+  LLVM_ATTRIBUTE_DEPRECATED(typedef ImportPath::Element AccessPathElement,
+                            "use ImportPath::Element instead");
 
 private:
   SourceLoc ImportLoc;
@@ -1475,13 +1476,13 @@ class ImportDecl final : public Decl,
   ModuleDecl *Mod = nullptr;
 
   ImportDecl(DeclContext *DC, SourceLoc ImportLoc, ImportKind K,
-             SourceLoc KindLoc, ArrayRef<AccessPathElement> Path);
+             SourceLoc KindLoc, ImportPath Path);
 
 public:
   static ImportDecl *create(ASTContext &C, DeclContext *DC,
                             SourceLoc ImportLoc, ImportKind Kind,
                             SourceLoc KindLoc,
-                            ArrayRef<AccessPathElement> Path,
+                            ImportPath Path,
                             ClangNode ClangN = ClangNode());
 
   /// Returns the import kind that is most appropriate for \p VD.
@@ -1496,26 +1497,25 @@ class ImportDecl final : public Decl,
   /// cannot be overloaded, returns None.
   static Optional<ImportKind> findBestImportKind(ArrayRef<ValueDecl *> Decls);
 
-  ArrayRef<AccessPathElement> getFullAccessPath() const {
-    return {getTrailingObjects<AccessPathElement>(),
-            static_cast<size_t>(Bits.ImportDecl.NumPathElements)};
+  ImportKind getImportKind() const {
+    return static_cast<ImportKind>(Bits.ImportDecl.ImportKind);
   }
 
-  ArrayRef<AccessPathElement> getModulePath() const {
-    auto result = getFullAccessPath();
-    if (getImportKind() != ImportKind::Module)
-      result = result.slice(0, result.size()-1);
-    return result;
+  ImportPath getImportPath() const {
+    return ImportPath({ getTrailingObjects<ImportPath::Element>(),
+                        static_cast<size_t>(Bits.ImportDecl.NumPathElements) });
   }
 
-  ArrayRef<AccessPathElement> getDeclPath() const {
-    if (getImportKind() == ImportKind::Module)
-      return {};
-    return getFullAccessPath().back();
+  LLVM_ATTRIBUTE_DEPRECATED(
+    ArrayRef<ImportPath::Element> getFullAccessPath() const,
+    "use getImportPath() instead") { return getImportPath().getRaw(); }
+
+  ImportPath::Module getModulePath() const {
+    return getImportPath().getModulePath(getImportKind());
   }
 
-  ImportKind getImportKind() const {
-    return static_cast<ImportKind>(Bits.ImportDecl.ImportKind);
+  ImportPath::Access getDeclPath() const {
+    return getImportPath().getAccessPath(getImportKind());
   }
 
   bool isExported() const {
@@ -1534,9 +1534,11 @@ class ImportDecl final : public Decl,
   }
 
   SourceLoc getStartLoc() const { return ImportLoc; }
-  SourceLoc getLocFromSource() const { return getFullAccessPath().front().Loc; }
+  SourceLoc getLocFromSource() const {
+    return getImportPath().getSourceRange().Start;
+  }
   SourceRange getSourceRange() const {
-    return SourceRange(ImportLoc, getFullAccessPath().back().Loc);
+    return SourceRange(ImportLoc, getImportPath().getSourceRange().End);
   }
   SourceLoc getKindLoc() const { return KindLoc; }
 

include/swift/AST/FileUnit.h

@@ -82,20 +82,20 @@ class FileUnit : public DeclContext {
   /// Find ValueDecls in the module and pass them to the given consumer object.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  virtual void lookupVisibleDecls(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupVisibleDecls(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer,
                                   NLKind lookupKind) const {}
 
   /// Finds all class members defined in this file.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  virtual void lookupClassMembers(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupClassMembers(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer) const {}
 
   /// Finds class members defined in this file with the given name.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  virtual void lookupClassMember(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupClassMember(ImportPath::Access accessPath,
                                  DeclName name,
                                  SmallVectorImpl<ValueDecl*> &results) const {}
 

include/swift/AST/ImportCache.h

@@ -108,17 +108,17 @@ class alignas(ModuleDecl::ImportedModule) ImportCache {
   llvm::DenseMap<const DeclContext *, ImportSet *> ImportSetForDC;
   llvm::DenseMap<std::tuple<const ModuleDecl *,
                             const DeclContext *>,
-                 ArrayRef<ModuleDecl::AccessPathTy>> VisibilityCache;
+                 ArrayRef<ImportPath::Access>> VisibilityCache;
   llvm::DenseMap<std::tuple<const ModuleDecl *,
                             const ModuleDecl *,
                             const DeclContext *>,
-                 ArrayRef<ModuleDecl::AccessPathTy>> ShadowCache;
+                 ArrayRef<ImportPath::Access>> ShadowCache;
 
-  ModuleDecl::AccessPathTy EmptyAccessPath;
+  ImportPath::Access EmptyAccessPath;
 
-  ArrayRef<ModuleDecl::AccessPathTy> allocateArray(
+  ArrayRef<ImportPath::Access> allocateArray(
       ASTContext &ctx,
-      SmallVectorImpl<ModuleDecl::AccessPathTy> &results);
+      SmallVectorImpl<ImportPath::Access> &results);
 
   ImportSet &getImportSet(ASTContext &ctx,
                           ArrayRef<ModuleDecl::ImportedModule> topLevelImports);
@@ -132,7 +132,7 @@ class alignas(ModuleDecl::ImportedModule) ImportCache {
 
   /// Returns all access paths into 'mod' that are visible from 'dc',
   /// including transitively, via re-exports.
-  ArrayRef<ModuleDecl::AccessPathTy>
+  ArrayRef<ImportPath::Access>
   getAllVisibleAccessPaths(const ModuleDecl *mod, const DeclContext *dc);
 
   bool isImportedBy(const ModuleDecl *mod,
@@ -142,7 +142,7 @@ class alignas(ModuleDecl::ImportedModule) ImportCache {
 
   /// Returns all access paths in 'mod' that are visible from 'dc' if we
   /// subtract imports of 'other'.
-  ArrayRef<ModuleDecl::AccessPathTy>
+  ArrayRef<ImportPath::Access>
   getAllAccessPathsNotShadowedBy(const ModuleDecl *mod,
                                  const ModuleDecl *other,
                                  const DeclContext *dc);

include/swift/AST/Module.h

@@ -203,17 +203,18 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   friend class DirectPrecedenceGroupLookupRequest;
 
 public:
-  typedef ArrayRef<Located<Identifier>> AccessPathTy;
+  LLVM_ATTRIBUTE_DEPRECATED(typedef ArrayRef<Located<Identifier>> AccessPathTy,
+                            "use ImportPath types instead");
   /// Convenience struct to keep track of a module along with its access path.
   struct alignas(uint64_t) ImportedModule {
     /// The access path from an import: `import Foo.Bar` -> `Foo.Bar`.
-    ModuleDecl::AccessPathTy accessPath;
+    ImportPath::Access accessPath;
     /// The actual module corresponding to the import.
     ///
     /// Invariant: The pointer is non-null.
     ModuleDecl *importedModule;
 
-    ImportedModule(ModuleDecl::AccessPathTy accessPath,
+    ImportedModule(ImportPath::Access accessPath,
                    ModuleDecl *importedModule)
         : accessPath(accessPath), importedModule(importedModule) {
       assert(this->importedModule);
@@ -225,7 +226,10 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     }
   };
 
-  static bool matchesAccessPath(AccessPathTy AccessPath, DeclName Name) {
+  LLVM_ATTRIBUTE_DEPRECATED(
+    static bool matchesAccessPath(AccessPathTy AccessPath, DeclName Name),
+    "use ImportPath::Access::matches() instead")
+  {
     assert(AccessPath.size() <= 1 && "can only refer to top-level decls");
 
     return AccessPath.empty()
@@ -240,8 +244,8 @@ class ModuleDecl : public DeclContext, public TypeDecl {
       if (lhs.importedModule != rhs.importedModule)
         return std::less<const ModuleDecl *>()(lhs.importedModule,
                                                rhs.importedModule);
-      if (lhs.accessPath.data() != rhs.accessPath.data())
-        return std::less<AccessPathTy::iterator>()(lhs.accessPath.begin(),
+      if (lhs.accessPath.getRaw().data() != rhs.accessPath.getRaw().data())
+        return std::less<ImportPath::Raw::iterator>()(lhs.accessPath.begin(),
                                                    rhs.accessPath.begin());
       return lhs.accessPath.size() < rhs.accessPath.size();
     }
@@ -583,7 +587,7 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// Find ValueDecls in the module and pass them to the given consumer object.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  void lookupVisibleDecls(AccessPathTy AccessPath,
+  void lookupVisibleDecls(ImportPath::Access AccessPath,
                           VisibleDeclConsumer &Consumer,
                           NLKind LookupKind) const;
 
@@ -596,13 +600,13 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// Finds all class members defined in this module.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  void lookupClassMembers(AccessPathTy accessPath,
+  void lookupClassMembers(ImportPath::Access accessPath,
                           VisibleDeclConsumer &consumer) const;
 
   /// Finds class members defined in this module with the given name.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
-  void lookupClassMember(AccessPathTy accessPath,
+  void lookupClassMember(ImportPath::Access accessPath,
                          DeclName name,
                          SmallVectorImpl<ValueDecl*> &results) const;
 
@@ -757,7 +761,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// identifiers.
   ///
   /// Source locations are ignored here.
-  static bool isSameAccessPath(AccessPathTy lhs, AccessPathTy rhs);
+  LLVM_ATTRIBUTE_DEPRECATED(
+    static bool isSameAccessPath(AccessPathTy lhs, AccessPathTy rhs),
+    "use ImportPath::Access::isSameAs() instead");
 
   /// Get the path for the file that this module came from, or an empty
   /// string if this is not applicable.
@@ -890,7 +896,7 @@ namespace llvm {
     static bool isEqual(const ModuleDecl::ImportedModule &lhs,
                         const ModuleDecl::ImportedModule &rhs) {
       return lhs.importedModule == rhs.importedModule &&
-             ModuleDecl::isSameAccessPath(lhs.accessPath, rhs.accessPath);
+             lhs.accessPath.isSameAs(rhs.accessPath);
     }
   };
 }

include/swift/AST/ModuleLoader.h

@@ -18,6 +18,7 @@
 #define SWIFT_AST_MODULE_LOADER_H
 
 #include "swift/AST/Identifier.h"
+#include "swift/AST/Import.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Located.h"
 #include "swift/Basic/SourceLoc.h"
@@ -143,7 +144,7 @@ class ModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(Located<Identifier> named) = 0;
+  virtual bool canImportModule(ImportPath::Element named) = 0;
 
   /// Import a module with the given module path.
   ///
@@ -155,8 +156,7 @@ class ModuleLoader {
   /// \returns the module referenced, if it could be loaded. Otherwise,
   /// emits a diagnostic and returns NULL.
   virtual
-  ModuleDecl *loadModule(SourceLoc importLoc,
-                         ArrayRef<Located<Identifier>> path) = 0;
+  ModuleDecl *loadModule(SourceLoc importLoc, ImportPath::Module path) = 0;
 
   /// Load extensions to the given nominal type.
   ///

include/swift/AST/ModuleNameLookup.h

@@ -65,7 +65,7 @@ void lookupInModule(const DeclContext *moduleOrFile,
 /// reexports, observing proper shadowing rules.
 void
 lookupVisibleDeclsInModule(const DeclContext *moduleOrFile,
-                           ModuleDecl::AccessPathTy accessPath,
+                           ImportPath::Access accessPath,
                            SmallVectorImpl<ValueDecl *> &decls,
                            NLKind lookupKind,
                            ResolutionKind resolutionKind,

include/swift/AST/SourceFile.h

@@ -407,14 +407,14 @@ class SourceFile final : public FileUnit {
   virtual void lookupValue(DeclName name, NLKind lookupKind,
                            SmallVectorImpl<ValueDecl*> &result) const override;
 
-  virtual void lookupVisibleDecls(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupVisibleDecls(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer,
                                   NLKind lookupKind) const override;
 
-  virtual void lookupClassMembers(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupClassMembers(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer) const override;
   virtual void
-  lookupClassMember(ModuleDecl::AccessPathTy accessPath, DeclName name,
+  lookupClassMember(ImportPath::Access accessPath, DeclName name,
                     SmallVectorImpl<ValueDecl*> &results) const override;
 
   void lookupObjCMethods(

include/swift/ClangImporter/ClangImporter.h

@@ -186,7 +186,7 @@ class ClangImporter final : public ClangModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(Located<Identifier> named) override;
+  virtual bool canImportModule(ImportPath::Element named) override;
 
   /// Import a module with the given module path.
   ///
@@ -202,7 +202,7 @@ class ClangImporter final : public ClangModuleLoader {
   /// emits a diagnostic and returns NULL.
   virtual ModuleDecl *loadModule(
                         SourceLoc importLoc,
-                        ArrayRef<Located<Identifier>> path)
+                        ImportPath::Module path)
                       override;
 
   /// Determine whether \c overlayDC is within an overlay module for the
@@ -440,7 +440,7 @@ class ClangImporter final : public ClangModuleLoader {
   /// Given the path of a Clang module, collect the names of all its submodules.
   /// Calling this function does not load the module.
   void collectSubModuleNames(
-      ArrayRef<Located<Identifier>> path,
+      ImportPath::Module path,
       std::vector<std::string> &names) const;
 
   /// Given a Clang module, decide whether this module is imported already.

include/swift/ClangImporter/ClangModule.h

@@ -72,15 +72,15 @@ class ClangModuleUnit final : public LoadedFile {
   lookupNestedType(Identifier name,
                    const NominalTypeDecl *baseType) const override;
 
-  virtual void lookupVisibleDecls(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupVisibleDecls(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer,
                                   NLKind lookupKind) const override;
 
-  virtual void lookupClassMembers(ModuleDecl::AccessPathTy accessPath,
+  virtual void lookupClassMembers(ImportPath::Access accessPath,
                                   VisibleDeclConsumer &consumer) const override;
 
   virtual void
-  lookupClassMember(ModuleDecl::AccessPathTy accessPath, DeclName name,
+  lookupClassMember(ImportPath::Access accessPath, DeclName name,
                     SmallVectorImpl<ValueDecl*> &decls) const override;
 
   void lookupObjCMethods(