Use IdentifierExpr as the child of ImplementsAttributeArgumentsSyntax

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift

@@ -619,17 +619,11 @@ public let ATTRIBUTE_NODES: [Node] = [
         documentation: "The comma separating the type and method name"
       ),
       Child(
-        name: "DeclBaseName",
-        kind: .node(kind: .token),
-        nameForDiagnostics: "declaration base name",
-        documentation: "The base name of the protocol's requirement."
-      ),
-      Child(
-        name: "DeclNameArguments",
-        kind: .node(kind: .declNameArguments),
-        nameForDiagnostics: "declaration name arguments",
-        documentation: "The argument labels of the protocol's requirement if it is a function requirement.",
-        isOptional: true
+        name: "DeclName",
+        deprecatedName: "Declname",
+        kind: .node(kind: .identifierExpr),
+        nameForDiagnostics: "declaration name",
+        documentation: "The value for this argument"
       ),
     ]
   ),

Sources/SwiftParser/Attributes.swift

@@ -827,12 +827,16 @@ extension Parser {
       .zeroArgCompoundNames,
       .operators,
     ])
+    let declName = RawIdentifierExprSyntax(
+      identifier: name,
+      declNameArguments: args,
+      arena: self.arena
+    )
     return RawImplementsAttributeArgumentsSyntax(
       type: type,
       unexpectedBeforeComma,
       comma: comma,
-      declBaseName: name,
-      declNameArguments: args,
+      declName: declName,
       arena: self.arena
     )
   }

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -180,10 +180,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "else body"
   case \ImplementsAttributeArgumentsSyntax.type:
     return "type"
-  case \ImplementsAttributeArgumentsSyntax.declBaseName:
-    return "declaration base name"
-  case \ImplementsAttributeArgumentsSyntax.declNameArguments:
-    return "declaration name arguments"
+  case \ImplementsAttributeArgumentsSyntax.declName:
+    return "declaration name"
   case \ImportDeclSyntax.attributes:
     return "attributes"
   case \ImportDeclSyntax.modifiers:

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1677,16 +1677,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenTypeAndComma"
   case \ImplementsAttributeArgumentsSyntax.comma:
     return "comma"
-  case \ImplementsAttributeArgumentsSyntax.unexpectedBetweenCommaAndDeclBaseName:
-    return "unexpectedBetweenCommaAndDeclBaseName"
-  case \ImplementsAttributeArgumentsSyntax.declBaseName:
-    return "declBaseName"
-  case \ImplementsAttributeArgumentsSyntax.unexpectedBetweenDeclBaseNameAndDeclNameArguments:
-    return "unexpectedBetweenDeclBaseNameAndDeclNameArguments"
-  case \ImplementsAttributeArgumentsSyntax.declNameArguments:
-    return "declNameArguments"
-  case \ImplementsAttributeArgumentsSyntax.unexpectedAfterDeclNameArguments:
-    return "unexpectedAfterDeclNameArguments"
+  case \ImplementsAttributeArgumentsSyntax.unexpectedBetweenCommaAndDeclName:
+    return "unexpectedBetweenCommaAndDeclName"
+  case \ImplementsAttributeArgumentsSyntax.declName:
+    return "declName"
+  case \ImplementsAttributeArgumentsSyntax.unexpectedAfterDeclName:
+    return "unexpectedAfterDeclName"
   case \ImplicitlyUnwrappedOptionalTypeSyntax.unexpectedBeforeWrappedType:
     return "unexpectedBeforeWrappedType"
   case \ImplicitlyUnwrappedOptionalTypeSyntax.wrappedType:

Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift

@@ -3829,6 +3829,65 @@ extension GenericWhereClauseSyntax {
   }
 }
 
+extension ImplementsAttributeArgumentsSyntax {
+  @available(*, deprecated, renamed: "unexpectedBetweenCommaAndDeclName")
+  public var unexpectedBetweenCommaAndDeclname: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenCommaAndDeclName
+    }
+    set {
+      unexpectedBetweenCommaAndDeclName = newValue
+    }
+  }
+  
+  @available(*, deprecated, renamed: "declName")
+  public var declname: IdentifierExprSyntax {
+    get {
+      return declName
+    }
+    set {
+      declName = newValue
+    }
+  }
+  
+  @available(*, deprecated, renamed: "unexpectedAfterDeclName")
+  public var unexpectedAfterDeclname: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedAfterDeclName
+    }
+    set {
+      unexpectedAfterDeclName = newValue
+    }
+  }
+  
+  @available(*, deprecated, message: "Use an initializer with declName argument(s).")
+  @_disfavoredOverload
+  public init(
+      leadingTrivia: Trivia? = nil,
+      _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil,
+      type: some TypeSyntaxProtocol,
+      _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil,
+      comma: TokenSyntax = .commaToken(),
+      _ unexpectedBetweenCommaAndDeclname: UnexpectedNodesSyntax? = nil,
+      declname: IdentifierExprSyntax,
+      _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil,
+      trailingTrivia: Trivia? = nil
+    
+  ) {
+    self.init(
+        leadingTrivia: leadingTrivia, 
+        unexpectedBeforeType, 
+        type: type, 
+        unexpectedBetweenTypeAndComma, 
+        comma: comma, 
+        unexpectedBetweenCommaAndDeclname, 
+        declName: declname, 
+        unexpectedAfterDeclname, 
+        trailingTrivia: trailingTrivia
+      )
+  }
+}
+
 extension ImportDeclSyntax {
   @available(*, deprecated, renamed: "unexpectedBetweenModifiersAndImportKeyword")
   public var unexpectedBetweenModifiersAndImportTok: UnexpectedNodesSyntax? {

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -11287,25 +11287,21 @@ public struct RawImplementsAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
       type: RawTypeSyntax, 
       _ unexpectedBetweenTypeAndComma: RawUnexpectedNodesSyntax? = nil, 
       comma: RawTokenSyntax, 
-      _ unexpectedBetweenCommaAndDeclBaseName: RawUnexpectedNodesSyntax? = nil, 
-      declBaseName: RawTokenSyntax, 
-      _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, 
-      declNameArguments: RawDeclNameArgumentsSyntax?, 
-      _ unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenCommaAndDeclName: RawUnexpectedNodesSyntax? = nil, 
+      declName: RawIdentifierExprSyntax, 
+      _ unexpectedAfterDeclName: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .implementsAttributeArguments, uninitializedCount: 9, arena: arena) { layout in
+      kind: .implementsAttributeArguments, uninitializedCount: 7, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeType?.raw
       layout[1] = type.raw
       layout[2] = unexpectedBetweenTypeAndComma?.raw
       layout[3] = comma.raw
-      layout[4] = unexpectedBetweenCommaAndDeclBaseName?.raw
-      layout[5] = declBaseName.raw
-      layout[6] = unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw
-      layout[7] = declNameArguments?.raw
-      layout[8] = unexpectedAfterDeclNameArguments?.raw
+      layout[4] = unexpectedBetweenCommaAndDeclName?.raw
+      layout[5] = declName.raw
+      layout[6] = unexpectedAfterDeclName?.raw
     }
     self.init(unchecked: raw)
   }
@@ -11326,25 +11322,17 @@ public struct RawImplementsAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
     layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenCommaAndDeclBaseName: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenCommaAndDeclName: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var declBaseName: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  public var declName: RawIdentifierExprSyntax {
+    layoutView.children[5].map(RawIdentifierExprSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterDeclName: RawUnexpectedNodesSyntax? {
     layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  
-  public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:))
-  }
-  
-  public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
 }
 
 @_spi(RawSyntax)

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -1449,16 +1449,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
         verify(layout[9], as: RawSyntax?.self)])
     assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
   case .implementsAttributeArguments:
-    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(.comma)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawIdentifierExprSyntax.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 .implicitlyUnwrappedOptionalType:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift

@@ -2783,6 +2783,7 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl
 /// ### Contained in
 /// 
 ///  - ``DynamicReplacementAttributeArgumentsSyntax``.``DynamicReplacementAttributeArgumentsSyntax/declName``
+///  - ``ImplementsAttributeArgumentsSyntax``.``ImplementsAttributeArgumentsSyntax/declName``
 ///  - ``SpecializeTargetFunctionArgumentSyntax``.``SpecializeTargetFunctionArgumentSyntax/declName``
 public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift

@@ -5353,7 +5353,6 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable {
 /// ### Contained in
 /// 
 ///  - ``IdentifierExprSyntax``.``IdentifierExprSyntax/declNameArguments``
-///  - ``ImplementsAttributeArgumentsSyntax``.``ImplementsAttributeArgumentsSyntax/declNameArguments``
 ///  - ``KeyPathPropertyComponentSyntax``.``KeyPathPropertyComponentSyntax/declNameArguments``
 ///  - ``MemberAccessExprSyntax``.``MemberAccessExprSyntax/declNameArguments``
 ///  - ``QualifiedDeclNameSyntax``.``QualifiedDeclNameSyntax/arguments``
@@ -10549,8 +10548,7 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable {
 /// 
 ///  - `type`: ``TypeSyntax``
 ///  - `comma`: `','`
-///  - `declBaseName`: ``TokenSyntax``
-///  - `declNameArguments`: ``DeclNameArgumentsSyntax``?
+///  - `declName`: ``IdentifierExprSyntax``
 ///
 /// ### Contained in
 /// 
@@ -10577,20 +10575,17 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
   ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   ///   - type: The type for which the method with this attribute implements a requirement.
   ///   - comma: The comma separating the type and method name
-  ///   - declBaseName: The base name of the protocol's requirement.
-  ///   - declNameArguments: The argument labels of the protocol's requirement if it is a function requirement.
+  ///   - declName: The value for this argument
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
       leadingTrivia: Trivia? = nil,
       _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil,
       type: some TypeSyntaxProtocol,
       _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil,
       comma: TokenSyntax = .commaToken(),
-      _ unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? = nil,
-      declBaseName: TokenSyntax,
-      _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil,
-      declNameArguments: DeclNameArgumentsSyntax? = nil,
-      _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenCommaAndDeclName: UnexpectedNodesSyntax? = nil,
+      declName: IdentifierExprSyntax,
+      _ unexpectedAfterDeclName: UnexpectedNodesSyntax? = nil,
       trailingTrivia: Trivia? = nil
 
   ) {
@@ -10601,22 +10596,18 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
             type, 
             unexpectedBetweenTypeAndComma, 
             comma, 
-            unexpectedBetweenCommaAndDeclBaseName, 
-            declBaseName, 
-            unexpectedBetweenDeclBaseNameAndDeclNameArguments, 
-            declNameArguments, 
-            unexpectedAfterDeclNameArguments
+            unexpectedBetweenCommaAndDeclName, 
+            declName, 
+            unexpectedAfterDeclName
           ))) { (arena, _) in
       let layout: [RawSyntax?] = [
           unexpectedBeforeType?.raw, 
           type.raw, 
           unexpectedBetweenTypeAndComma?.raw, 
           comma.raw, 
-          unexpectedBetweenCommaAndDeclBaseName?.raw, 
-          declBaseName.raw, 
-          unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, 
-          declNameArguments?.raw, 
-          unexpectedAfterDeclNameArguments?.raw
+          unexpectedBetweenCommaAndDeclName?.raw, 
+          declName.raw, 
+          unexpectedAfterDeclName?.raw
         ]
       let raw = RawSyntax.makeLayout(
         kind: SyntaxKind.implementsAttributeArguments,
@@ -10669,7 +10660,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     }
   }
 
-  public var unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenCommaAndDeclName: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -10678,17 +10669,17 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     }
   }
 
-  /// The base name of the protocol's requirement.
-  public var declBaseName: TokenSyntax {
+  /// The value for this argument
+  public var declName: IdentifierExprSyntax {
     get {
-      return TokenSyntax(data.child(at: 5, parent: Syntax(self))!)
+      return IdentifierExprSyntax(data.child(at: 5, parent: Syntax(self))!)
     }
     set(value) {
       self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.data, arena: SyntaxArena()))
     }
   }
 
-  public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? {
+  public var unexpectedAfterDeclName: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -10697,36 +10688,15 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
     }
   }
 
-  /// The argument labels of the protocol's requirement if it is a function requirement.
-  public var declNameArguments: DeclNameArgumentsSyntax? {
-    get {
-      return data.child(at: 7, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init)
-    }
-    set(value) {
-      self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.data, arena: SyntaxArena()))
-    }
-  }
-  
-  public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? {
-    get {
-      return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
-    }
-    set(value) {
-      self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.data, arena: SyntaxArena()))
-    }
-  }
-  
   public static var structure: SyntaxNodeStructure {
     return .layout([
           \Self.unexpectedBeforeType, 
           \Self.type, 
           \Self.unexpectedBetweenTypeAndComma, 
           \Self.comma, 
-          \Self.unexpectedBetweenCommaAndDeclBaseName, 
-          \Self.declBaseName, 
-          \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, 
-          \Self.declNameArguments, 
-          \Self.unexpectedAfterDeclNameArguments
+          \Self.unexpectedBetweenCommaAndDeclName, 
+          \Self.declName, 
+          \Self.unexpectedAfterDeclName
         ])
   }
 }