Do TODO to rename `QualifiedDecl` -> `QualifiedName` (#3543)

Renaming since the parse node does not represent a declaration.

toolchain/check/decl_name_stack.cpp

@@ -28,8 +28,8 @@ auto DeclNameStack::FinishName() -> NameContext {
   CARBON_CHECK(decl_name_stack_.back().state != NameContext::State::Finished)
       << "Finished name twice";
   if (context_->node_stack()
-          .PopAndDiscardSoloParseNodeIf<Parse::NodeKind::QualifiedDecl>()) {
-    // Any parts from a QualifiedDecl will already have been processed
+          .PopAndDiscardSoloParseNodeIf<Parse::NodeKind::QualifiedName>()) {
+    // Any parts from a QualifiedName will already have been processed
     // into the name.
   } else {
     // The name had no qualifiers, so we need to process the node now.
@@ -198,15 +198,14 @@ auto DeclNameStack::TryResolveQualifier(NameContext& name_context,
         context_->NoteIncompleteClass(class_decl->class_id, builder);
         builder.Emit();
       } else {
-        CARBON_DIAGNOSTIC(
-            QualifiedDeclInNonScope, Error,
-            "Declaration qualifiers are only allowed for entities "
-            "that provide a scope.");
-        CARBON_DIAGNOSTIC(QualifiedDeclNonScopeEntity, Note,
+        CARBON_DIAGNOSTIC(QualifiedNameInNonScope, Error,
+                          "Name qualifiers are only allowed for entities that "
+                          "provide a scope.");
+        CARBON_DIAGNOSTIC(QualifiedNameNonScopeEntity, Note,
                           "Non-scope entity referenced here.");
         context_->emitter()
-            .Build(parse_node, QualifiedDeclInNonScope)
-            .Note(name_context.parse_node, QualifiedDeclNonScopeEntity)
+            .Build(parse_node, QualifiedNameInNonScope)
+            .Note(name_context.parse_node, QualifiedNameNonScopeEntity)
             .Emit();
       }
       name_context.state = NameContext::State::Error;

toolchain/check/handle_name.cpp

@@ -315,24 +315,24 @@ auto HandleSelfValueNameExpr(Context& context, Parse::NodeId parse_node)
   return HandleNameAsExpr(context, parse_node, SemIR::NameId::SelfValue);
 }
 
-auto HandleQualifiedDecl(Context& context, Parse::NodeId parse_node) -> bool {
+auto HandleQualifiedName(Context& context, Parse::NodeId parse_node) -> bool {
   auto [parse_node2, name_id2] = context.node_stack().PopNameWithParseNode();
 
   Parse::NodeId parse_node1 = context.node_stack().PeekParseNode();
   switch (context.parse_tree().node_kind(parse_node1)) {
-    case Parse::NodeKind::QualifiedDecl:
-      // This is the second or subsequent QualifiedDecl in a chain.
-      // Nothing to do: the first QualifiedDecl remains as a
-      // bracketing node for later QualifiedDecls.
+    case Parse::NodeKind::QualifiedName:
+      // This is the second or subsequent QualifiedName in a chain.
+      // Nothing to do: the first QualifiedName remains as a
+      // bracketing node for later QualifiedNames.
       break;
 
     case Parse::NodeKind::IdentifierName: {
-      // This is the first QualifiedDecl in a chain, and starts with an
+      // This is the first QualifiedName in a chain, and starts with an
       // identifier name.
       auto name_id =
           context.node_stack().Pop<Parse::NodeKind::IdentifierName>();
       context.decl_name_stack().ApplyNameQualifier(parse_node1, name_id);
-      // Add the QualifiedDecl so that it can be used for bracketing.
+      // Add the QualifiedName so that it can be used for bracketing.
       context.node_stack().Push(parse_node);
       break;
     }

toolchain/check/node_stack.h

@@ -401,7 +401,7 @@ class NodeStack {
       case Parse::NodeKind::ImplicitParamListStart:
       case Parse::NodeKind::InterfaceIntroducer:
       case Parse::NodeKind::LetIntroducer:
-      case Parse::NodeKind::QualifiedDecl:
+      case Parse::NodeKind::QualifiedName:
       case Parse::NodeKind::ReturnedModifier:
       case Parse::NodeKind::ReturnStatementStart:
       case Parse::NodeKind::ReturnVarModifier:

toolchain/diagnostics/diagnostic_kind.def

@@ -216,8 +216,8 @@ CARBON_DIAGNOSTIC_KIND(ExplicitAsConversionFailure)
 CARBON_DIAGNOSTIC_KIND(TypeExprEvaluationFailure)
 CARBON_DIAGNOSTIC_KIND(QualifiedDeclOutsideScopeEntity)
 CARBON_DIAGNOSTIC_KIND(QualifiedDeclInIncompleteClassScope)
-CARBON_DIAGNOSTIC_KIND(QualifiedDeclInNonScope)
-CARBON_DIAGNOSTIC_KIND(QualifiedDeclNonScopeEntity)
+CARBON_DIAGNOSTIC_KIND(QualifiedNameInNonScope)
+CARBON_DIAGNOSTIC_KIND(QualifiedNameNonScopeEntity)
 CARBON_DIAGNOSTIC_KIND(QualifiedExprInIncompleteClassScope)
 CARBON_DIAGNOSTIC_KIND(QualifiedExprUnsupported)
 CARBON_DIAGNOSTIC_KIND(QualifiedExprNameNotFound)

toolchain/parse/handle_period.cpp

@@ -20,7 +20,7 @@ static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
   if (context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::Identifier,
                                       NodeKind::IdentifierName)) {
     // OK, `.` identifier.
-  } else if (node_kind != NodeKind::QualifiedDecl &&
+  } else if (node_kind != NodeKind::QualifiedName &&
              context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::Base,
                                              NodeKind::BaseName)) {
     // OK, `.base`. This is allowed in any name context other than declaring a
@@ -49,7 +49,7 @@ static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
 }
 
 auto HandlePeriodAsDecl(Context& context) -> void {
-  HandlePeriodOrArrow(context, NodeKind::QualifiedDecl,
+  HandlePeriodOrArrow(context, NodeKind::QualifiedName,
                       /*is_arrow=*/false);
 }
 

toolchain/parse/node_kind.def

@@ -218,7 +218,7 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(LibrarySpecifier, 1, Library)
 // `namespace`:
 //   NamespaceStart
 //   _repeated_ _external_: modifier
-//   _external_: IdentifierName or QualifiedDecl
+//   _external_: IdentifierName or QualifiedName
 // Namespace
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(NamespaceStart, 0, Namespace)
 CARBON_PARSE_NODE_KIND_BRACKET(Namespace, NamespaceStart, CARBON_IF_VALID(Semi))
@@ -235,7 +235,7 @@ CARBON_PARSE_NODE_KIND_BRACKET(CodeBlock, CodeBlockStart,
 // `fn`:
 //     FunctionIntroducer
 //     _repeated_ _external_: modifier
-//     _external_: IdentifierName or QualifiedDecl
+//     _external_: IdentifierName or QualifiedName
 //     _optional_ _external_: ImplicitParamList
 //     _external_: TuplePattern
 //       _external_: type expression
@@ -448,13 +448,13 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExprComma, 0, Comma)
 CARBON_PARSE_NODE_KIND_BRACKET(CallExpr, CallExprStart, CloseParen)
 
 // A qualified declaration, such as `a.b`:
-//   _external_: IdentifierName or QualifiedDecl
+//   _external_: IdentifierName or QualifiedName
 //   _external_: IdentifierName
-// QualifiedDecl
+// QualifiedName
 //
 // TODO: This will eventually more general expressions, for example with
 // `GenericType(type_args).ChildType(child_type_args).Name`.
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(QualifiedDecl, 2, Period)
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(QualifiedName, 2, Period)
 
 // A member access expression, such as `a.b` or
 // `GetObject().(Interface.member)`:
@@ -611,7 +611,7 @@ CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Virtual)
 // `class`:
 //     ClassIntroducer
 //     _repeated_ _external_: modifier
-//     _external_: IdentifierName or QualifiedDecl
+//     _external_: IdentifierName or QualifiedName
 //     _optional_ _external_: ImplicitParamList
 //     _optional_ _external_: TuplePattern
 //   ClassDefinitionStart
@@ -642,7 +642,7 @@ CARBON_PARSE_NODE_KIND_BRACKET(BaseDecl, BaseIntroducer, CARBON_IF_VALID(Semi))
 // `interface`:
 //     InterfaceIntroducer
 //     _repeated_ _external_: modifier
-//     _external_: IdentifierName or QualifiedDecl
+//     _external_: IdentifierName or QualifiedName
 //     _optional_ _external_: ImplicitParamList
 //     _optional_ _external_: TuplePattern
 //   InterfaceDefinitionStart
@@ -690,7 +690,7 @@ CARBON_PARSE_NODE_KIND_BRACKET(ImplDecl, ImplIntroducer, CARBON_IF_VALID(Semi))
 // `constraint`:
 //     NamedConstraintIntroducer
 //     _repeated_ _external_: modifier
-//     _external_: IdentifierName or QualifiedDecl
+//     _external_: IdentifierName or QualifiedName
 //     _optional_ _external_: ImplicitParamList
 //     _optional_ _external_: TuplePattern
 //   NamedConstraintDefinitionStart

toolchain/parse/testdata/namespace/fail_incomplete_name.carbon

@@ -15,7 +15,7 @@ namespace Foo.;
 // CHECK:STDOUT:       {kind: 'NamespaceStart', text: 'namespace'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'Foo'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: ';', has_error: yes},
-// CHECK:STDOUT:       {kind: 'QualifiedDecl', text: '.', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'QualifiedName', text: '.', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'Namespace', text: ';', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/namespace/nested.carbon

@@ -20,14 +20,14 @@ fn Foo.Bar.Baz() {
 // CHECK:STDOUT:       {kind: 'NamespaceStart', text: 'namespace'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'Foo'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'Bar'},
-// CHECK:STDOUT:       {kind: 'QualifiedDecl', text: '.', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'QualifiedName', text: '.', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'Namespace', text: ';', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'Foo'},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'Bar'},
-// CHECK:STDOUT:           {kind: 'QualifiedDecl', text: '.', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'QualifiedName', text: '.', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'IdentifierName', text: 'Baz'},
-// CHECK:STDOUT:         {kind: 'QualifiedDecl', text: '.', subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'QualifiedName', text: '.', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 9},

toolchain/parse/typed_nodes.h

@@ -128,13 +128,11 @@ using SelfTypeNameExpr =
 using BaseName = LeafNode<NodeKind::BaseName>;
 
 // A qualified name: `A.B`.
-//
-// TODO: This is not a declaration. Rename this parse node.
-struct QualifiedDecl {
+struct QualifiedName {
   static constexpr auto Kind =
-      NodeKind::QualifiedDecl.Define(NodeCategory::NameComponent);
+      NodeKind::QualifiedName.Define(NodeCategory::NameComponent);
 
-  // For now, this is either an IdentifierName or a QualifiedDecl.
+  // For now, this is either an IdentifierName or a QualifiedName.
   AnyNameComponentId lhs;
 
   // TODO: This will eventually need to support more general expressions, for
@@ -206,7 +204,7 @@ struct Namespace {
 
   NamespaceStartId introducer;
   llvm::SmallVector<AnyModifierId> modifiers;
-  NodeIdOneOf<IdentifierName, QualifiedDecl> name;
+  NodeIdOneOf<IdentifierName, QualifiedName> name;
 };
 
 // Pattern nodes
@@ -287,7 +285,7 @@ struct FunctionSignature {
 
   FunctionIntroducerId introducer;
   llvm::SmallVector<AnyModifierId> modifiers;
-  // For now, this is either an IdentifierName or a QualifiedDecl.
+  // For now, this is either an IdentifierName or a QualifiedName.
   AnyNameComponentId name;
   std::optional<ImplicitParamListId> implicit_params;
   TuplePatternId params;