[NFC] Rename “DeclPath” -> “AccessPath”

To avoid ambiguity, ImportResolution and a few other things used the term “decl path” instead of “access path”. Switch back to the correct terminology now that the compiler is becoming more consistent about it.

Author: beccadax

include/swift/AST/Decl.h

@@ -1514,7 +1514,7 @@ class ImportDecl final : public Decl,
     return getImportPath().getModulePath(getImportKind());
   }
 
-  ImportPath::Access getDeclPath() const {
+  ImportPath::Access getAccessPath() const {
     return getImportPath().getAccessPath(getImportKind());
   }
 

include/swift/AST/Import.h

@@ -229,7 +229,7 @@ class ImportPath : public detail::ImportPathBase<ImportPath> {
   ///
   /// \c ImportPath::Access is essentially a wrapper around \c ArrayRef and does
   /// not own its elements, so something else needs to manage their lifetime.
-  /// \c ImportDecl owns the memory backing \c ImportDecl::getDeclPath().
+  /// \c ImportDecl owns the memory backing \c ImportDecl::getAccessPath().
   class Access : public detail::ImportPathBase<Access> {
   public:
     /// A helper type which encapsulates a temporary vector and can produce a

lib/IRGen/IRGenDebugInfo.cpp

@@ -2089,7 +2089,7 @@ void IRGenDebugInfoImpl::emitImport(ImportDecl *D) {
     return;
 
   assert(D->getModule() && "compiler-synthesized ImportDecl is incomplete");
-  ModuleDecl::ImportedModule Imported = { D->getDeclPath(), D->getModule() };
+  ModuleDecl::ImportedModule Imported = { D->getAccessPath(), D->getModule() };
   auto DIMod = getOrCreateModule(Imported);
   auto L = getDebugLoc(*this, D);
   auto *File = getOrCreateFile(L.Filename);

lib/Sema/ImportResolution.cpp

@@ -75,8 +75,8 @@ struct UnboundImport {
   /// If this is a scoped import, the names of the declaration being imported;
   /// otherwise empty. (Currently the compiler doesn't support nested scoped
   /// imports, so there should always be zero or one elements, but
-  /// \c AccessPathTy is the common currency type for this.)
-  ImportPath::Access declPath;
+  /// \c ImportPath::Access is the common currency type for this.)
+  ImportPath::Access accessPath;
 
   // Names of explicitly imported SPI groups via @_spi.
   ArrayRef<Identifier> spiGroups;
@@ -141,7 +141,7 @@ struct UnboundImport {
   /// Create an \c ImportedModuleDesc from the information in this
   /// UnboundImport.
   ImportedModuleDesc makeDesc(ModuleDecl *module) const {
-    return ImportedModuleDesc({ declPath, module }, options,
+    return ImportedModuleDesc({ accessPath, module }, options,
                               privateImportFileName, spiGroups);
   }
 
@@ -501,7 +501,7 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
 /// Create an UnboundImport for a user-written import declaration.
 UnboundImport::UnboundImport(ImportDecl *ID)
   : importLoc(ID->getLoc()), options(), privateImportFileName(),
-    modulePath(ID->getModulePath()), declPath(ID->getDeclPath()),
+    modulePath(ID->getModulePath()), accessPath(ID->getAccessPath()),
     importOrUnderlyingModuleDecl(ID)
 {
   if (ID->isExported())
@@ -850,34 +850,34 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
   /// we've performed import resolution, since that can introduce additional
   /// imports (such as cross-import overlays) which could provide the declaration.
   auto &ctx = module->getASTContext();
-  auto declPath = import->getDeclPath();
+  auto accessPath = import->getAccessPath();
   auto modulePath = import->getModulePath();
   auto *topLevelModule = module->getTopLevelModule();
 
   // Lookup the referenced decl in the top-level module. This is necessary as
   // the Clang importer currently handles submodules by importing their decls
   // into the top-level module.
   // FIXME: Doesn't handle scoped testable imports correctly.
-  assert(declPath.size() == 1 && "can't handle sub-decl imports");
+  assert(accessPath.size() == 1 && "can't handle sub-decl imports");
   SmallVector<ValueDecl *, 8> decls;
-  lookupInModule(topLevelModule, declPath.front().Item, decls,
+  lookupInModule(topLevelModule, accessPath.front().Item, decls,
                  NLKind::QualifiedLookup, ResolutionKind::Overloadable,
                  import->getDeclContext()->getModuleScopeContext());
 
   auto importLoc = import->getLoc();
   if (decls.empty()) {
     ctx.Diags.diagnose(importLoc, diag::decl_does_not_exist_in_module,
                        static_cast<unsigned>(importKind),
-                       declPath.front().Item, modulePath.front().Item)
-      .highlight(declPath.getSourceRange());
+                       accessPath.front().Item, modulePath.front().Item)
+      .highlight(accessPath.getSourceRange());
     return ArrayRef<ValueDecl *>();
   }
 
   Optional<ImportKind> actualKind = ImportDecl::findBestImportKind(decls);
   if (!actualKind.hasValue()) {
     // FIXME: print entire module name?
     ctx.Diags.diagnose(importLoc, diag::ambiguous_decl_in_module,
-                       declPath.front().Item, module->getName());
+                       accessPath.front().Item, module->getName());
     for (auto next : decls)
       ctx.Diags.diagnose(next, diag::found_candidate);
 
@@ -899,7 +899,7 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
     } else {
       emittedDiag.emplace(ctx.Diags.diagnose(
           importLoc, diag::imported_decl_is_wrong_kind,
-          declPath.front().Item, getImportKindString(importKind),
+          accessPath.front().Item, getImportKindString(importKind),
           static_cast<unsigned>(*actualKind)));
     }
 
@@ -940,7 +940,7 @@ UnboundImport::UnboundImport(ASTContext &ctx, const UnboundImport &base,
                     .copyTo(ctx)),
       // If the declaring import was scoped, inherit that scope in the
       // overlay's import.
-      declPath(declaringImport.module.accessPath),
+      accessPath(declaringImport.module.accessPath),
       importOrUnderlyingModuleDecl(declaringImport.module.importedModule)
 {
   // A cross-import is never private or testable, and never comes from a private