Use DeclReferenceExprSyntax in QualifiedDeclNameSyntax

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift

@@ -777,23 +777,10 @@ public let ATTRIBUTE_NODES: [Node] = [
         isOptional: true
       ),
       Child(
-        name: "Name",
-        kind: .token(choices: [
-          .token(tokenKind: "IdentifierToken"),
-          .keyword(text: "self"),
-          .keyword(text: "Self"),
-          .keyword(text: "init"),
-          .token(tokenKind: "BinaryOperatorToken"),
-        ]),
-        nameForDiagnostics: "base name",
-        documentation: "The base name of the referenced function."
-      ),
-      Child(
-        name: "Arguments",
-        kind: .node(kind: .declNameArguments),
-        nameForDiagnostics: "arguments",
-        documentation: "The argument labels of the referenced function, optionally specified.",
-        isOptional: true
+        name: "DeclName",
+        kind: .node(kind: .declReferenceExpr),
+        nameForDiagnostics: "name",
+        documentation: "The name of the referenced function."
       ),
     ]
   ),

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -457,18 +457,6 @@ class ValidateSyntaxNodes: XCTestCase {
     assertFailuresMatchXFails(
       failures,
       expectedFailures: [
-        // MARK: DeclNameArguments
-        // FIXME: IdentifierExprSyntax etc. should probably use DeclName as child instead of Name and Arguments
-        ValidationFailure(
-          node: .qualifiedDeclName,
-          message:
-            "child 'Arguments' is named inconsistently with 'KeyPathPropertyComponentSyntax.DeclNameArguments', which has the same type ('DeclNameArgumentsSyntax')"
-        ),
-        ValidationFailure(
-          node: .declReferenceExpr,
-          message:
-            "child 'ArgumentNames' is named inconsistently with 'KeyPathPropertyComponentSyntax.DeclNameArguments', which has the same type ('DeclNameArgumentsSyntax')"
-        ),
         // MARK: Alternate names for InitializerClauseSyntax
         // The cases below don’t have intializers but just a syntactic element that happens to be spelled the same
         ValidationFailure(

Sources/SwiftParser/Names.swift

@@ -160,8 +160,11 @@ extension Parser {
     return RawQualifiedDeclNameSyntax(
       baseType: type,
       period: period,
-      name: name,
-      arguments: args,
+      declName: RawDeclReferenceExprSyntax(
+        baseName: name,
+        argumentNames: args,
+        arena: self.arena
+      ),
       arena: self.arena
     )
   }

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -1659,48 +1659,6 @@ extension PrecedenceGroupRelationSyntax {
   }
 }
 
-extension QualifiedDeclNameSyntax {
-  enum NameOptions: TokenSpecSet {
-    case identifier
-    case `self`
-    case `Self`
-    case `init`
-    case binaryOperator
-    
-    init?(lexeme: Lexer.Lexeme) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.identifier):
-        self = .identifier
-      case TokenSpec(.`self`):
-        self = .`self`
-      case TokenSpec(.`Self`):
-        self = .`Self`
-      case TokenSpec(.`init`):
-        self = .`init`
-      case TokenSpec(.binaryOperator):
-        self = .binaryOperator
-      default:
-        return nil
-      }
-    }
-    
-    var spec: TokenSpec {
-      switch self {
-      case .identifier:
-        return .identifier
-      case .`self`:
-        return .keyword(.`self`)
-      case .`Self`:
-        return .keyword(.`Self`)
-      case .`init`:
-        return .keyword(.`init`)
-      case .binaryOperator:
-        return .binaryOperator
-      }
-    }
-  }
-}
-
 extension SameTypeRequirementSyntax {
   enum EqualOptions: TokenSpecSet {
     case binaryOperator

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -284,10 +284,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "generic where clause"
   case \QualifiedDeclNameSyntax.baseType:
     return "base type"
-  case \QualifiedDeclNameSyntax.name:
-    return "base name"
-  case \QualifiedDeclNameSyntax.arguments:
-    return "arguments"
+  case \QualifiedDeclNameSyntax.declName:
+    return "name"
   case \RepeatStmtSyntax.body:
     return "body"
   case \RepeatStmtSyntax.condition:

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -2683,16 +2683,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenBaseTypeAndPeriod"
   case \QualifiedDeclNameSyntax.period:
     return "period"
-  case \QualifiedDeclNameSyntax.unexpectedBetweenPeriodAndName:
-    return "unexpectedBetweenPeriodAndName"
-  case \QualifiedDeclNameSyntax.name:
-    return "name"
-  case \QualifiedDeclNameSyntax.unexpectedBetweenNameAndArguments:
-    return "unexpectedBetweenNameAndArguments"
-  case \QualifiedDeclNameSyntax.arguments:
-    return "arguments"
-  case \QualifiedDeclNameSyntax.unexpectedAfterArguments:
-    return "unexpectedAfterArguments"
+  case \QualifiedDeclNameSyntax.unexpectedBetweenPeriodAndDeclName:
+    return "unexpectedBetweenPeriodAndDeclName"
+  case \QualifiedDeclNameSyntax.declName:
+    return "declName"
+  case \QualifiedDeclNameSyntax.unexpectedAfterDeclName:
+    return "unexpectedAfterDeclName"
   case \RegexLiteralExprSyntax.unexpectedBeforeOpeningPounds:
     return "unexpectedBeforeOpeningPounds"
   case \RegexLiteralExprSyntax.openingPounds:

Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift

@@ -6616,13 +6616,13 @@ extension QualifiedDeclNameSyntax {
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenPeriodAndName")
-  public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? {
+  @available(*, deprecated, renamed: "unexpectedBetweenPeriodAndDeclName")
+  public var unexpectedBetweenDotAndDeclName: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenPeriodAndName
+      return unexpectedBetweenPeriodAndDeclName
     }
     set {
-      unexpectedBetweenPeriodAndName = newValue
+      unexpectedBetweenPeriodAndDeclName = newValue
     }
   }
 
@@ -6634,11 +6634,9 @@ extension QualifiedDeclNameSyntax {
       baseType: (some TypeSyntaxProtocol)? = TypeSyntax?.none,
       _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil,
       dot: TokenSyntax? = nil,
-      _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil,
-      name: TokenSyntax,
-      _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil,
-      arguments: DeclNameArgumentsSyntax? = nil,
-      _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenDotAndDeclName: UnexpectedNodesSyntax? = nil,
+      declName: DeclReferenceExprSyntax,
+      _ unexpectedAfterDeclName: UnexpectedNodesSyntax? = nil,
       trailingTrivia: Trivia? = nil
 
   ) {
@@ -6648,11 +6646,9 @@ extension QualifiedDeclNameSyntax {
         baseType: baseType, 
         unexpectedBetweenBaseTypeAndDot, 
         period: dot, 
-        unexpectedBetweenDotAndName, 
-        name: name, 
-        unexpectedBetweenNameAndArguments, 
-        arguments: arguments, 
-        unexpectedAfterArguments, 
+        unexpectedBetweenDotAndDeclName, 
+        declName: declName, 
+        unexpectedAfterDeclName, 
         trailingTrivia: trailingTrivia
       )
   }

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -17778,25 +17778,21 @@ public struct RawQualifiedDeclNameSyntax: RawSyntaxNodeProtocol {
       baseType: RawTypeSyntax?, 
       _ unexpectedBetweenBaseTypeAndPeriod: RawUnexpectedNodesSyntax? = nil, 
       period: RawTokenSyntax?, 
-      _ unexpectedBetweenPeriodAndName: RawUnexpectedNodesSyntax? = nil, 
-      name: RawTokenSyntax, 
-      _ unexpectedBetweenNameAndArguments: RawUnexpectedNodesSyntax? = nil, 
-      arguments: RawDeclNameArgumentsSyntax?, 
-      _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenPeriodAndDeclName: RawUnexpectedNodesSyntax? = nil, 
+      declName: RawDeclReferenceExprSyntax, 
+      _ unexpectedAfterDeclName: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .qualifiedDeclName, uninitializedCount: 9, arena: arena) { layout in
+      kind: .qualifiedDeclName, uninitializedCount: 7, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeBaseType?.raw
       layout[1] = baseType?.raw
       layout[2] = unexpectedBetweenBaseTypeAndPeriod?.raw
       layout[3] = period?.raw
-      layout[4] = unexpectedBetweenPeriodAndName?.raw
-      layout[5] = name.raw
-      layout[6] = unexpectedBetweenNameAndArguments?.raw
-      layout[7] = arguments?.raw
-      layout[8] = unexpectedAfterArguments?.raw
+      layout[4] = unexpectedBetweenPeriodAndDeclName?.raw
+      layout[5] = declName.raw
+      layout[6] = unexpectedAfterDeclName?.raw
     }
     self.init(unchecked: raw)
   }
@@ -17817,25 +17813,17 @@ public struct RawQualifiedDeclNameSyntax: RawSyntaxNodeProtocol {
     layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenPeriodAndName: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenPeriodAndDeclName: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var name: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  public var declName: RawDeclReferenceExprSyntax {
+    layoutView.children[5].map(RawDeclReferenceExprSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenNameAndArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterDeclName: RawUnexpectedNodesSyntax? {
     layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  
-  public var arguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:))
-  }
-  
-  public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
 }
 
 @_spi(RawSyntax)

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -2166,22 +2166,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
     assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
   case .qualifiedDeclName:
-    assert(layout.count == 9)
+    assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTypeSyntax?.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.period)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [
-            .tokenKind(.identifier), 
-            .keyword("self"), 
-            .keyword("Self"), 
-            .keyword("init"), 
-            .tokenKind(.binaryOperator)
-          ]))
+    assertNoError(kind, 5, verify(layout[5], as: RawDeclReferenceExprSyntax.self))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 7, verify(layout[7], as: RawDeclNameArgumentsSyntax?.self))
-    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
   case .regexLiteralExpr:
     assert(layout.count == 11)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift

@@ -1824,6 +1824,7 @@ public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 ///  - ``ImplementsAttributeArgumentsSyntax``.``ImplementsAttributeArgumentsSyntax/declName``
 ///  - ``KeyPathPropertyComponentSyntax``.``KeyPathPropertyComponentSyntax/declName``
 ///  - ``MemberAccessExprSyntax``.``MemberAccessExprSyntax/declName``
+///  - ``QualifiedDeclNameSyntax``.``QualifiedDeclNameSyntax/declName``
 ///  - ``SpecializeTargetFunctionArgumentSyntax``.``SpecializeTargetFunctionArgumentSyntax/declName``
 public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax