Redo the Modeling for @convention's Arguments

Author: CodaFi

Sources/SwiftParser/Attributes.swift

@@ -794,6 +794,54 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseConventionArguments() -> RawSyntax {
+    if let witnessMethod = self.consumeIfContextualKeyword("witness_method") {
+      let (unexpectedBeforeColon, colon) = self.expect(.colon)
+      let name = self.parseAnyIdentifier()
+      return RawSyntax(RawConventionWitnessMethodAttributeArgumentsSyntax(
+        witnessMethodLabel: witnessMethod,
+        unexpectedBeforeColon,
+        colon: colon,
+        protocolName: name,
+        arena: self.arena))
+    } else {
+      let label = self.consumeAnyToken()
+      let unexpectedBeforeComma: RawUnexpectedNodesSyntax?
+      let comma: RawTokenSyntax?
+      let cTypeLabel: RawTokenSyntax?
+      let unexpectedBeforeColon: RawUnexpectedNodesSyntax?
+      let colon: RawTokenSyntax?
+      let unexpectedBeforeCTypeString: RawUnexpectedNodesSyntax?
+      let cTypeString: RawTokenSyntax?
+      if self.at(.comma) {
+        (unexpectedBeforeComma, comma) = self.expect(.comma)
+        cTypeLabel = self.consumeAnyToken()
+        (unexpectedBeforeColon, colon) = self.expect(.colon)
+        (unexpectedBeforeCTypeString, cTypeString) = self.expect(.stringLiteral)
+      } else {
+        unexpectedBeforeComma = nil
+        comma = nil
+        cTypeLabel = nil
+        unexpectedBeforeColon = nil
+        colon = nil
+        unexpectedBeforeCTypeString = nil
+        cTypeString = nil
+      }
+      return RawSyntax(RawConventionAttributeArgumentsSyntax(
+        conventionLabel: label,
+        unexpectedBeforeComma,
+        comma: comma,
+        cTypeLabel: cTypeLabel,
+        unexpectedBeforeColon,
+        colon: colon,
+        unexpectedBeforeCTypeString,
+        cTypeString: cTypeString,
+        arena: self.arena))
+    }
+  }
+}
+
 // MARK: Lookahead
 
 extension Parser.Lookahead {

Sources/SwiftParser/Types.swift

@@ -803,7 +803,7 @@ extension Parser {
       let (unexpectedBeforeAt, at) = self.expect(.atSign)
       let (unexpectedBeforeIdent, ident) = self.expectIdentifier()
       let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-      let (unexpectedBeforeArgument, argument) = self.expectIdentifier()
+      let arguments = self.parseConventionArguments()
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       return RawSyntax(
         RawAttributeSyntax(
@@ -813,8 +813,7 @@ extension Parser {
           attributeName: ident,
           unexpectedBeforeLeftParen,
           leftParen: leftParen,
-          unexpectedBeforeArgument,
-          argument: RawSyntax(argument),
+          argument: arguments,
           unexpectedBeforeRightParen,
           rightParen: rightParen,
           tokenList: nil,

Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md

@@ -362,6 +362,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/BackDeployVersionListSyntax>
 - <doc:SwiftSyntax/BackDeployVersionArgumentSyntax>
 - <doc:SwiftSyntax/OpaqueReturnTypeOfAttributeArgumentsSyntax>
+- <doc:SwiftSyntax/ConventionAttributeArgumentsSyntax>
+- <doc:SwiftSyntax/ConventionWitnessMethodAttributeArgumentsSyntax>
 - <doc:SwiftSyntax/SwitchCaseListSyntax>
 - <doc:SwiftSyntax/WhereClauseSyntax>
 - <doc:SwiftSyntax/CatchClauseListSyntax>

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -10660,6 +10660,152 @@ public struct RawOpaqueReturnTypeOfAttributeArgumentsSyntax: RawSyntaxNodeProtoc
   }
 }
 
+@_spi(RawSyntax)
+public struct RawConventionAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .conventionAttributeArguments
+  }
+
+  public var raw: RawSyntax
+  init(raw: RawSyntax) {
+    assert(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
+    guard Self.isKindOf(other.raw) else { return nil }
+    self.init(raw: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeConventionLabel: RawUnexpectedNodesSyntax? = nil,
+    conventionLabel: RawTokenSyntax,
+    _ unexpectedBetweenConventionLabelAndComma: RawUnexpectedNodesSyntax? = nil,
+    comma: RawTokenSyntax?,
+    _ unexpectedBetweenCommaAndCTypeLabel: RawUnexpectedNodesSyntax? = nil,
+    cTypeLabel: RawTokenSyntax?,
+    _ unexpectedBetweenCTypeLabelAndColon: RawUnexpectedNodesSyntax? = nil,
+    colon: RawTokenSyntax?,
+    _ unexpectedBetweenColonAndCTypeString: RawUnexpectedNodesSyntax? = nil,
+    cTypeString: RawTokenSyntax?,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .conventionAttributeArguments, uninitializedCount: 10, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeConventionLabel?.raw
+      layout[1] = conventionLabel.raw
+      layout[2] = unexpectedBetweenConventionLabelAndComma?.raw
+      layout[3] = comma?.raw
+      layout[4] = unexpectedBetweenCommaAndCTypeLabel?.raw
+      layout[5] = cTypeLabel?.raw
+      layout[6] = unexpectedBetweenCTypeLabelAndColon?.raw
+      layout[7] = colon?.raw
+      layout[8] = unexpectedBetweenColonAndCTypeString?.raw
+      layout[9] = cTypeString?.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeConventionLabel: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var conventionLabel: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenConventionLabelAndComma: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var comma: RawTokenSyntax? {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
+  }
+  public var unexpectedBetweenCommaAndCTypeLabel: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var cTypeLabel: RawTokenSyntax? {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
+  }
+  public var unexpectedBetweenCTypeLabelAndColon: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var colon: RawTokenSyntax? {
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
+  }
+  public var unexpectedBetweenColonAndCTypeString: RawUnexpectedNodesSyntax? {
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var cTypeString: RawTokenSyntax? {
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
+  }
+}
+
+@_spi(RawSyntax)
+public struct RawConventionWitnessMethodAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .conventionWitnessMethodAttributeArguments
+  }
+
+  public var raw: RawSyntax
+  init(raw: RawSyntax) {
+    assert(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
+    guard Self.isKindOf(other.raw) else { return nil }
+    self.init(raw: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeWitnessMethodLabel: RawUnexpectedNodesSyntax? = nil,
+    witnessMethodLabel: RawTokenSyntax,
+    _ unexpectedBetweenWitnessMethodLabelAndColon: RawUnexpectedNodesSyntax? = nil,
+    colon: RawTokenSyntax,
+    _ unexpectedBetweenColonAndProtocolName: RawUnexpectedNodesSyntax? = nil,
+    protocolName: RawTokenSyntax,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .conventionWitnessMethodAttributeArguments, uninitializedCount: 6, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeWitnessMethodLabel?.raw
+      layout[1] = witnessMethodLabel.raw
+      layout[2] = unexpectedBetweenWitnessMethodLabelAndColon?.raw
+      layout[3] = colon.raw
+      layout[4] = unexpectedBetweenColonAndProtocolName?.raw
+      layout[5] = protocolName.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeWitnessMethodLabel: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var witnessMethodLabel: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenWitnessMethodLabelAndColon: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var colon: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenColonAndProtocolName: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var protocolName: RawTokenSyntax {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol {
   var layoutView: RawSyntaxLayoutView {

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -1531,6 +1531,28 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[5], as: RawTokenSyntax.self)
     break
+  case .conventionAttributeArguments:
+    assert(layout.count == 10)
+    _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[1], as: RawTokenSyntax.self)
+    _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[3], as: RawTokenSyntax?.self)
+    _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[5], as: RawTokenSyntax?.self)
+    _verify(layout[6], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[7], as: RawTokenSyntax?.self)
+    _verify(layout[8], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[9], as: RawTokenSyntax?.self)
+    break
+  case .conventionWitnessMethodAttributeArguments:
+    assert(layout.count == 6)
+    _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[1], as: RawTokenSyntax.self)
+    _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[3], as: RawTokenSyntax.self)
+    _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[5], as: RawTokenSyntax.self)
+    break
   case .labeledStmt:
     assert(layout.count == 6)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -383,6 +383,10 @@ extension Syntax {
       return node
     case .opaqueReturnTypeOfAttributeArguments(let node):
       return node
+    case .conventionAttributeArguments(let node):
+      return node
+    case .conventionWitnessMethodAttributeArguments(let node):
+      return node
     case .labeledStmt(let node):
       return node
     case .continueStmt(let node):
@@ -747,6 +751,8 @@ extension SyntaxKind {
     case .backDeployVersionList: return BackDeployVersionListSyntax.self
     case .backDeployVersionArgument: return BackDeployVersionArgumentSyntax.self
     case .opaqueReturnTypeOfAttributeArguments: return OpaqueReturnTypeOfAttributeArgumentsSyntax.self
+    case .conventionAttributeArguments: return ConventionAttributeArgumentsSyntax.self
+    case .conventionWitnessMethodAttributeArguments: return ConventionWitnessMethodAttributeArgumentsSyntax.self
     case .labeledStmt: return LabeledStmtSyntax.self
     case .continueStmt: return ContinueStmtSyntax.self
     case .whileStmt: return WhileStmtSyntax.self

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1300,6 +1300,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: ConventionAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ConventionAttributeArgumentsSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: LabeledStmtSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -193,6 +193,8 @@ public enum SyntaxEnum {
   case backDeployVersionList(BackDeployVersionListSyntax)
   case backDeployVersionArgument(BackDeployVersionArgumentSyntax)
   case opaqueReturnTypeOfAttributeArguments(OpaqueReturnTypeOfAttributeArgumentsSyntax)
+  case conventionAttributeArguments(ConventionAttributeArgumentsSyntax)
+  case conventionWitnessMethodAttributeArguments(ConventionWitnessMethodAttributeArgumentsSyntax)
   case labeledStmt(LabeledStmtSyntax)
   case continueStmt(ContinueStmtSyntax)
   case whileStmt(WhileStmtSyntax)
@@ -643,6 +645,10 @@ public enum SyntaxEnum {
       return "version"
     case .opaqueReturnTypeOfAttributeArguments:
       return "opaque return type arguments"
+    case .conventionAttributeArguments:
+      return "@convention(...) arguments"
+    case .conventionWitnessMethodAttributeArguments:
+      return "@convention(...) arguments for witness methods"
     case .labeledStmt:
       return "labeled statement"
     case .continueStmt:
@@ -1187,6 +1193,10 @@ public extension Syntax {
       return .backDeployVersionArgument(BackDeployVersionArgumentSyntax(self)!)
     case .opaqueReturnTypeOfAttributeArguments:
       return .opaqueReturnTypeOfAttributeArguments(OpaqueReturnTypeOfAttributeArgumentsSyntax(self)!)
+    case .conventionAttributeArguments:
+      return .conventionAttributeArguments(ConventionAttributeArgumentsSyntax(self)!)
+    case .conventionWitnessMethodAttributeArguments:
+      return .conventionWitnessMethodAttributeArguments(ConventionWitnessMethodAttributeArgumentsSyntax(self)!)
     case .labeledStmt:
       return .labeledStmt(LabeledStmtSyntax(self)!)
     case .continueStmt: