NFC: Rename NameBinding to ImportResolution

Author: hamishknight

include/swift/AST/SourceFile.h

@@ -318,8 +318,8 @@ class SourceFile final : public FileUnit {
   enum ASTStage_t {
     /// The source file is not name bound or type checked.
     Unprocessed,
-    /// Name binding has completed.
-    NameBound,
+    /// Import resolution has completed.
+    ImportsResolved,
     /// Type checking has completed.
     TypeChecked
   };

include/swift/Subsystems.h

@@ -118,33 +118,32 @@ namespace swift {
                               bool TokenizeInterpolatedString = true,
                               ArrayRef<Token> SplitTokens = ArrayRef<Token>());
 
-  /// Once parsing is complete, this walks the AST to resolve imports, record
-  /// operators, and do other top-level validation.
-  void performNameBinding(SourceFile &SF);
+  /// This walks the AST to resolve imports.
+  void performImportResolution(SourceFile &SF);
 
   /// Once type-checking is complete, this instruments code with calls to an
   /// intrinsic that record the expected values of local variables so they can
   /// be compared against the results from the debugger.
   void performDebuggerTestingTransform(SourceFile &SF);
 
-  /// Once parsing and name-binding are complete, this optionally transforms the
-  /// ASTs to add calls to external logging functions.
+  /// Once type checking is complete, this optionally transforms the ASTs to add
+  /// calls to external logging functions.
   ///
   /// \param HighPerformance True if the playground transform should omit
   /// instrumentation that has a high runtime performance impact.
   void performPlaygroundTransform(SourceFile &SF, bool HighPerformance);
 
-  /// Once parsing and name-binding are complete this optionally walks the ASTs
-  /// to add calls to externally provided functions that simulate
-  /// "program counter"-like debugging events. See the comment at the top of
-  /// lib/Sema/PCMacro.cpp for a description of the calls inserted.
+  /// Once type checking is complete this optionally walks the ASTs to add calls
+  /// to externally provided functions that simulate "program counter"-like
+  /// debugging events. See the comment at the top of lib/Sema/PCMacro.cpp for a
+  /// description of the calls inserted.
   void performPCMacro(SourceFile &SF);
 
   /// Bind all 'extension' visible from \p SF to the extended nominal.
   void bindExtensions(SourceFile &SF);
 
-  /// Once parsing and name-binding are complete, this walks the AST to resolve
-  /// types and diagnose problems therein.
+  /// Once import resolution is complete, this walks the AST to resolve types
+  /// and diagnose problems therein.
   void performTypeChecking(SourceFile &SF);
 
   /// Now that we have type-checked an entire module, perform any type

lib/AST/Module.cpp

@@ -1182,7 +1182,7 @@ lookupOperatorDeclForName(const FileUnit &File, SourceLoc Loc,
   }
 
   auto &SF = cast<SourceFile>(File);
-  assert(SF.ASTStage >= SourceFile::NameBound);
+  assert(SF.ASTStage >= SourceFile::ImportsResolved);
 
   // Check if the decl exists on the file.
   if (auto *op = OperatorLookup<OP_DECL>::lookup(eval, desc))

lib/Frontend/Frontend.cpp

@@ -752,7 +752,7 @@ shouldImplicityImportSwiftOnoneSupportModule(CompilerInvocation &Invocation) {
 }
 
 void CompilerInstance::performParseAndResolveImportsOnly() {
-  performSemaUpTo(SourceFile::NameBound);
+  performSemaUpTo(SourceFile::ImportsResolved);
 }
 
 void CompilerInstance::performSema() {
@@ -926,12 +926,12 @@ void CompilerInstance::parseAndCheckTypesUpTo(
     auto *SF = dyn_cast<SourceFile>(File);
     if (!SF)
       return true;
-    return SF->ASTStage >= SourceFile::NameBound;
+    return SF->ASTStage >= SourceFile::ImportsResolved;
   }) && "some files have not yet had their imports resolved");
   MainModule->setHasResolvedImports();
 
   forEachFileToTypeCheck([&](SourceFile &SF) {
-    if (limitStage == SourceFile::NameBound) {
+    if (limitStage == SourceFile::ImportsResolved) {
       bindExtensions(SF);
       return;
     }
@@ -951,8 +951,8 @@ void CompilerInstance::parseAndCheckTypesUpTo(
     }
   });
 
-  // If the limiting AST stage is name binding, we're done.
-  if (limitStage <= SourceFile::NameBound) {
+  // If the limiting AST stage is import resolution, we're done.
+  if (limitStage <= SourceFile::ImportsResolved) {
     return;
   }
 
@@ -967,8 +967,8 @@ void CompilerInstance::parseLibraryFile(
       SourceFileKind::Library, implicitImports.kind, BufferID);
   addAdditionalInitialImportsTo(NextInput, implicitImports);
 
-  // Name binding will lazily trigger parsing of the file.
-  performNameBinding(*NextInput);
+  // Import resolution will lazily trigger parsing of the file.
+  performImportResolution(*NextInput);
 }
 
 bool CompilerInstance::parsePartialModulesAndLibraryFiles(
@@ -997,7 +997,7 @@ bool CompilerInstance::parsePartialModulesAndLibraryFiles(
 
 void CompilerInstance::parseAndTypeCheckMainFileUpTo(
     SourceFile::ASTStage_t LimitStage) {
-  assert(LimitStage >= SourceFile::NameBound);
+  assert(LimitStage >= SourceFile::ImportsResolved);
   FrontendStatsTracer tracer(getStatsReporter(),
                              "parse-and-typecheck-main-file");
   bool mainIsPrimary =
@@ -1010,13 +1010,13 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
   auto DidSuppressWarnings = Diags.getSuppressWarnings();
   Diags.setSuppressWarnings(DidSuppressWarnings || !mainIsPrimary);
 
-  // For a primary, perform type checking if needed. Otherwise, just do name
-  // binding.
+  // For a primary, perform type checking if needed. Otherwise, just do import
+  // resolution.
   if (mainIsPrimary && LimitStage >= SourceFile::TypeChecked) {
     performTypeChecking(MainFile);
   } else {
     assert(!TheSILModule && "Should perform type checking for SIL");
-    performNameBinding(MainFile);
+    performImportResolution(MainFile);
   }
 
   // Parse the SIL decls if needed.

lib/IDE/CompletionInstance.cpp

@@ -326,7 +326,7 @@ bool CompletionInstance::performCachedOperaitonIfPossible(
 
     // Re-process the whole file (parsing will be lazily triggered). Still
     // re-use imported modules.
-    performNameBinding(*newSF);
+    performImportResolution(*newSF);
     bindExtensions(*newSF);
 
 #ifndef NDEBUG

lib/Sema/CMakeLists.txt

@@ -25,10 +25,10 @@ add_swift_host_library(swiftSema STATIC
   DerivedConformanceError.cpp
   DerivedConformanceRawRepresentable.cpp
   DerivedConformances.cpp
+  ImportResolution.cpp
   InstrumenterSupport.cpp
   LookupVisibleDecls.cpp
   MiscDiagnostics.cpp
-  NameBinding.cpp
   PCMacro.cpp
   PlaygroundTransform.cpp
   ResilienceDiagnostics.cpp

lib/Sema/NameBinding.cpp lib/Sema/ImportResolution.cpp

@@ -1,8 +1,8 @@
-//===--- NameBinding.cpp - Name Binding -----------------------------------===//
+//===--- ImportResolution.cpp - Import Resolution -------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -11,11 +11,10 @@
 //===----------------------------------------------------------------------===//
 //
 //  This file performs import resolution.
-//  FIXME: Rename NameBinding to ImportResolution.
 //
 //===----------------------------------------------------------------------===//
 
-#define DEBUG_TYPE "swift-name-binding"
+#define DEBUG_TYPE "swift-import-resolution"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ModuleLoader.h"
@@ -41,7 +40,7 @@
 using namespace swift;
 
 //===----------------------------------------------------------------------===//
-// MARK: NameBinder and supporting types
+// MARK: ImportResolver and supporting types
 //===----------------------------------------------------------------------===//
 
 using ImportedModule = ModuleDecl::ImportedModule;
@@ -50,8 +49,8 @@ using ImportOptions = SourceFile::ImportOptions;
 using ImportFlags = SourceFile::ImportFlags;
 
 namespace {
-/// Represents an import which the NameBinder knows exists, but which has not
-/// yet had its options checked, module loaded, or cross-imports found.
+/// Represents an import which the ImportResolver knows exists, but which has
+/// not yet had its options checked, module loaded, or cross-imports found.
 ///
 /// An UnboundImport may represent a physical ImportDecl written in the
 /// source, or it may represent a cross-import overlay that has been found and
@@ -160,8 +159,8 @@ struct UnboundImport {
                            Diag<Identifier> diagID);
 };
 
-class NameBinder final : public DeclVisitor<NameBinder> {
-  friend DeclVisitor<NameBinder>;
+class ImportResolver final : public DeclVisitor<ImportResolver> {
+  friend DeclVisitor<ImportResolver>;
 
   SourceFile &SF;
   ASTContext &ctx;
@@ -196,9 +195,7 @@ class NameBinder final : public DeclVisitor<NameBinder> {
   size_t nextModuleToCrossImport = 0;
 
 public:
-  NameBinder(SourceFile &SF)
-    : SF(SF), ctx(SF.getASTContext())
-  { }
+  ImportResolver(SourceFile &SF) : SF(SF), ctx(SF.getASTContext()) {}
 
   /// Retrieve the finalized imports.
   ArrayRef<ImportedModuleDesc> getFinishedImports() const {
@@ -258,54 +255,53 @@ class NameBinder final : public DeclVisitor<NameBinder> {
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
-// MARK: performNameBinding
+// MARK: performImportResolution
 //===----------------------------------------------------------------------===//
 
-/// performNameBinding - Once parsing is complete, this walks the AST to
-/// resolve imports.
+/// performImportResolution - This walks the AST to resolve imports.
 ///
-/// Most names are actually bound by the type checker, but before we can
-/// type-check a source file, we need to make declarations imported from other
-/// modules available. Name binding processes top-level \c ImportDecl nodes
-/// to perform this task, along with related validation.
+/// Before we can type-check a source file, we need to make declarations
+/// imported from other modules available. This is done by processing top-level
+/// \c ImportDecl nodes, along with related validation.
 ///
-/// Name binding operates on a parsed but otherwise unvalidated AST.
-void swift::performNameBinding(SourceFile &SF) {
+/// Import resolution operates on a parsed but otherwise unvalidated AST.
+void swift::performImportResolution(SourceFile &SF) {
   FrontendStatsTracer tracer(SF.getASTContext().Stats,
-                             "Name binding");
+                             "Import resolution");
 
   // Make sure we skip adding the standard library imports if the
   // source file is empty.
-  if (SF.ASTStage == SourceFile::NameBound || SF.getTopLevelDecls().empty()) {
-    SF.ASTStage = SourceFile::NameBound;
+  if (SF.ASTStage == SourceFile::ImportsResolved ||
+      SF.getTopLevelDecls().empty()) {
+    SF.ASTStage = SourceFile::ImportsResolved;
     return;
   }
 
-  NameBinder Binder(SF);
+  ImportResolver resolver(SF);
 
   // Resolve each import declaration.
   for (auto D : SF.getTopLevelDecls())
-    Binder.visit(D);
+    resolver.visit(D);
 
-  SF.addImports(Binder.getFinishedImports());
+  SF.addImports(resolver.getFinishedImports());
 
-  SF.ASTStage = SourceFile::NameBound;
+  SF.ASTStage = SourceFile::ImportsResolved;
   verify(SF);
 }
 
 //===----------------------------------------------------------------------===//
 // MARK: Import handling generally
 //===----------------------------------------------------------------------===//
 
-void NameBinder::visitImportDecl(ImportDecl *ID) {
+void ImportResolver::visitImportDecl(ImportDecl *ID) {
   assert(unboundImports.empty());
 
   unboundImports.emplace_back(ID);
   while(!unboundImports.empty())
     bindImport(unboundImports.pop_back_val());
 }
 
-void NameBinder::bindImport(UnboundImport &&I) {
+void ImportResolver::bindImport(UnboundImport &&I) {
   auto ID = I.getImportDecl();
 
   if (!I.checkNotTautological(SF)) {
@@ -343,7 +339,7 @@ void NameBinder::bindImport(UnboundImport &&I) {
     ID.get()->setModule(M);
 }
 
-void NameBinder::addImport(const UnboundImport &I, ModuleDecl *M) {
+void ImportResolver::addImport(const UnboundImport &I, ModuleDecl *M) {
   auto importDesc = I.makeDesc(M);
   addVisibleModules(importDesc);
   boundImports.push_back(importDesc);
@@ -353,7 +349,8 @@ void NameBinder::addImport(const UnboundImport &I, ModuleDecl *M) {
 // MARK: Import module loading
 //===----------------------------------------------------------------------===//
 
-ModuleDecl *NameBinder::getModule(ArrayRef<Located<Identifier>> modulePath) {
+ModuleDecl *
+ImportResolver::getModule(ArrayRef<Located<Identifier>> modulePath) {
   assert(!modulePath.empty());
   auto moduleID = modulePath[0];
 
@@ -667,7 +664,7 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
 
   // If we weren't able to load the module referenced by the import, we're done.
   // The fact that we failed to load the module has already been diagnosed by
-  // name binding.
+  // import resolution.
   auto *module = import->getModule();
   if (!module)
     return ArrayRef<ValueDecl *>();
@@ -676,8 +673,8 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
   ///
   /// We validate the scope by making sure that the named declaration exists
   /// and is of the kind indicated by the keyword. This can't be done until
-  /// we've performed name binding, since that can introduce additional imports
-  /// (such as cross-import overlays) which could provide the declaration.
+  /// 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 modulePath = import->getModulePath();
@@ -789,16 +786,16 @@ UnboundImport::UnboundImport(ASTContext &ctx,
     options |= ImportFlags::ImplementationOnly;
 }
 
-void NameBinder::crossImport(ModuleDecl *M, UnboundImport &I) {
+void ImportResolver::crossImport(ModuleDecl *M, UnboundImport &I) {
   // FIXME: There is a fundamental problem with this find-as-we-go approach:
   // The '@_exported import'-ed modules in this module's other files should be
   // taken into account, but they haven't been bound yet, and binding them would
   // require cross-importing. Chicken, meet egg.
   //
-  // The way to fix this is probably to restructure name binding so we first
-  // bind all exported imports in all files, then bind all other imports in each
-  // file. This may become simpler if we bind all ImportDecls before we start
-  // computing cross-imports, but I haven't figured that part out yet.
+  // The way to fix this is probably to restructure import resolution so we
+  // first bind all exported imports in all files, then bind all other imports
+  // in each file. This may become simpler if we bind all ImportDecls before we
+  // start computing cross-imports, but I haven't figured that part out yet.
   //
   // Fixing this is tracked within Apple by rdar://problem/59527118. I haven't
   // filed an SR because I plan to address it myself, but if this comment is
@@ -855,11 +852,10 @@ void NameBinder::crossImport(ModuleDecl *M, UnboundImport &I) {
   nextModuleToCrossImport = crossImportableModules.size();
 }
 
-void
-NameBinder::findCrossImportsInLists(UnboundImport &I,
-                                    ArrayRef<ImportedModuleDesc> declaring,
-                                    ArrayRef<ImportedModuleDesc> bystanding,
-                                    bool shouldDiagnoseRedundantCrossImports) {
+void ImportResolver::findCrossImportsInLists(
+    UnboundImport &I, ArrayRef<ImportedModuleDesc> declaring,
+    ArrayRef<ImportedModuleDesc> bystanding,
+    bool shouldDiagnoseRedundantCrossImports) {
   for (auto &declaringImport : declaring) {
     if (!canCrossImport(declaringImport))
       continue;
@@ -874,10 +870,10 @@ NameBinder::findCrossImportsInLists(UnboundImport &I,
   }
 }
 
-void NameBinder::findCrossImports(UnboundImport &I,
-                                  const ImportedModuleDesc &declaringImport,
-                                  const ImportedModuleDesc &bystandingImport,
-                                  bool shouldDiagnoseRedundantCrossImports) {
+void ImportResolver::findCrossImports(
+    UnboundImport &I, const ImportedModuleDesc &declaringImport,
+    const ImportedModuleDesc &bystandingImport,
+    bool shouldDiagnoseRedundantCrossImports) {
   assert(&declaringImport != &bystandingImport);
 
   LLVM_DEBUG(
@@ -935,7 +931,7 @@ static bool isSubmodule(ModuleDecl* M) {
   return clangMod && clangMod->Parent;
 }
 
-void NameBinder::addVisibleModules(ImportedModuleDesc importDesc) {
+void ImportResolver::addVisibleModules(ImportedModuleDesc importDesc) {
   // FIXME: namelookup::getAllImports() doesn't quite do what we need (mainly
   // w.r.t. scoped imports), but it seems like we could extend it to do so, and
   // then eliminate most of this.