Model the Argument List of @_opaqueReturnTypeOf

Author: CodaFi

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

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

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -10577,6 +10577,69 @@ public struct RawBackDeployVersionArgumentSyntax: RawSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawOpaqueReturnTypeOfAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .opaqueReturnTypeOfAttributeArguments
+  }
+
+  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(
+    _ unexpectedBeforeMangledName: RawUnexpectedNodesSyntax? = nil,
+    mangledName: RawTokenSyntax,
+    _ unexpectedBetweenMangledNameAndComma: RawUnexpectedNodesSyntax? = nil,
+    comma: RawTokenSyntax,
+    _ unexpectedBetweenCommaAndOrdinal: RawUnexpectedNodesSyntax? = nil,
+    ordinal: RawTokenSyntax,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .opaqueReturnTypeOfAttributeArguments, uninitializedCount: 6, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeMangledName?.raw
+      layout[1] = mangledName.raw
+      layout[2] = unexpectedBetweenMangledNameAndComma?.raw
+      layout[3] = comma.raw
+      layout[4] = unexpectedBetweenCommaAndOrdinal?.raw
+      layout[5] = ordinal.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeMangledName: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var mangledName: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenMangledNameAndComma: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var comma: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenCommaAndOrdinal: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var ordinal: RawTokenSyntax {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol {
   var layoutView: RawSyntaxLayoutView {

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -1518,6 +1518,15 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[3], as: RawTokenSyntax?.self)
     break
+  case .opaqueReturnTypeOfAttributeArguments:
+    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

@@ -381,6 +381,8 @@ extension Syntax {
       return node
     case .backDeployVersionArgument(let node):
       return node
+    case .opaqueReturnTypeOfAttributeArguments(let node):
+      return node
     case .labeledStmt(let node):
       return node
     case .continueStmt(let node):
@@ -742,6 +744,7 @@ extension SyntaxKind {
     case .backDeployAttributeSpecList: return BackDeployAttributeSpecListSyntax.self
     case .backDeployVersionList: return BackDeployVersionListSyntax.self
     case .backDeployVersionArgument: return BackDeployVersionArgumentSyntax.self
+    case .opaqueReturnTypeOfAttributeArguments: return OpaqueReturnTypeOfAttributeArgumentsSyntax.self
     case .labeledStmt: return LabeledStmtSyntax.self
     case .continueStmt: return ContinueStmtSyntax.self
     case .whileStmt: return WhileStmtSyntax.self

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

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

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -192,6 +192,7 @@ public enum SyntaxEnum {
   case backDeployAttributeSpecList(BackDeployAttributeSpecListSyntax)
   case backDeployVersionList(BackDeployVersionListSyntax)
   case backDeployVersionArgument(BackDeployVersionArgumentSyntax)
+  case opaqueReturnTypeOfAttributeArguments(OpaqueReturnTypeOfAttributeArgumentsSyntax)
   case labeledStmt(LabeledStmtSyntax)
   case continueStmt(ContinueStmtSyntax)
   case whileStmt(WhileStmtSyntax)
@@ -639,6 +640,8 @@ public enum SyntaxEnum {
       return "version list"
     case .backDeployVersionArgument:
       return "version"
+    case .opaqueReturnTypeOfAttributeArguments:
+      return "opaque return type arguments"
     case .labeledStmt:
       return "labeled statement"
     case .continueStmt:
@@ -1179,6 +1182,8 @@ public extension Syntax {
       return .backDeployVersionList(BackDeployVersionListSyntax(self)!)
     case .backDeployVersionArgument:
       return .backDeployVersionArgument(BackDeployVersionArgumentSyntax(self)!)
+    case .opaqueReturnTypeOfAttributeArguments:
+      return .opaqueReturnTypeOfAttributeArguments(OpaqueReturnTypeOfAttributeArgumentsSyntax(self)!)
     case .labeledStmt:
       return .labeledStmt(LabeledStmtSyntax(self)!)
     case .continueStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -4723,6 +4723,35 @@ public enum SyntaxFactory {
     ], arena: .default))
     return BackDeployVersionArgumentSyntax(data)
   }
+  @available(*, deprecated, message: "Use initializer on OpaqueReturnTypeOfAttributeArgumentsSyntax")
+  public static func makeOpaqueReturnTypeOfAttributeArguments(_ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, mangledName: TokenSyntax, _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, comma: TokenSyntax, _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, ordinal: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax {
+    let layout: [RawSyntax?] = [
+      unexpectedBeforeMangledName?.raw,
+      mangledName.raw,
+      unexpectedBetweenMangledNameAndComma?.raw,
+      comma.raw,
+      unexpectedBetweenCommaAndOrdinal?.raw,
+      ordinal.raw,
+    ]
+    let raw = RawSyntax.makeLayout(kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments,
+      from: layout, arena: .default)
+    let data = SyntaxData.forRoot(raw)
+    return OpaqueReturnTypeOfAttributeArgumentsSyntax(data)
+  }
+
+  @available(*, deprecated, message: "Use initializer on OpaqueReturnTypeOfAttributeArgumentsSyntax")
+  public static func makeBlankOpaqueReturnTypeOfAttributeArguments(presence: SourcePresence = .present) -> OpaqueReturnTypeOfAttributeArgumentsSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .opaqueReturnTypeOfAttributeArguments,
+      from: [
+      nil,
+      RawSyntax.makeMissingToken(kind: TokenKind.stringLiteral(""), arena: .default),
+      nil,
+      RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: .default),
+      nil,
+      RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: .default),
+    ], arena: .default))
+    return OpaqueReturnTypeOfAttributeArgumentsSyntax(data)
+  }
   @available(*, deprecated, message: "Use initializer on LabeledStmtSyntax")
   public static func makeLabeledStmt(_ unexpectedBeforeLabelName: UnexpectedNodesSyntax? = nil, labelName: TokenSyntax, _ unexpectedBetweenLabelNameAndLabelColon: UnexpectedNodesSyntax? = nil, labelColon: TokenSyntax, _ unexpectedBetweenLabelColonAndStatement: UnexpectedNodesSyntax? = nil, statement: StmtSyntax) -> LabeledStmtSyntax {
     let layout: [RawSyntax?] = [

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -193,6 +193,7 @@ public enum SyntaxKind {
   case backDeployAttributeSpecList
   case backDeployVersionList
   case backDeployVersionArgument
+  case opaqueReturnTypeOfAttributeArguments
   case labeledStmt
   case continueStmt
   case whileStmt

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1255,6 +1255,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `OpaqueReturnTypeOfAttributeArgumentsSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `LabeledStmtSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3722,6 +3729,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(_ data: SyntaxData) -> Syntax {
+      let node = OpaqueReturnTypeOfAttributeArgumentsSyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return visit(node)
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplLabeledStmtSyntax(_ data: SyntaxData) -> Syntax {
       let node = LabeledStmtSyntax(data)
@@ -5006,6 +5023,8 @@ open class SyntaxRewriter {
       return visitImplBackDeployVersionListSyntax
     case .backDeployVersionArgument:
       return visitImplBackDeployVersionArgumentSyntax
+    case .opaqueReturnTypeOfAttributeArguments:
+      return visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax
     case .labeledStmt:
       return visitImplLabeledStmtSyntax
     case .continueStmt:
@@ -5549,6 +5568,8 @@ open class SyntaxRewriter {
       return visitImplBackDeployVersionListSyntax(data)
     case .backDeployVersionArgument:
       return visitImplBackDeployVersionArgumentSyntax(data)
+    case .opaqueReturnTypeOfAttributeArguments:
+      return visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(data)
     case .labeledStmt:
       return visitImplLabeledStmtSyntax(data)
     case .continueStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift

@@ -724,6 +724,10 @@ public protocol SyntaxTransformVisitor {
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: BackDeployVersionArgumentSyntax) -> ResultType
+  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> ResultType
   /// Visiting `LabeledStmtSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -2143,6 +2147,12 @@ extension SyntaxTransformVisitor {
   public func visit(_ node: BackDeployVersionArgumentSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
+  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
   /// Visiting `LabeledStmtSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3030,6 +3040,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .backDeployVersionArgument(let derived):
       return visit(derived)
+    case .opaqueReturnTypeOfAttributeArguments(let derived):
+      return visit(derived)
     case .labeledStmt(let derived):
       return visit(derived)
     case .continueStmt(let derived):

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -1801,6 +1801,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `BackDeployVersionArgumentSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BackDeployVersionArgumentSyntax) {}
+  /// Visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `OpaqueReturnTypeOfAttributeArgumentsSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) {}
   /// Visiting `LabeledStmtSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4695,6 +4705,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(_ data: SyntaxData) {
+      let node = OpaqueReturnTypeOfAttributeArgumentsSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && !node.raw.layoutView!.children.isEmpty {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplLabeledStmtSyntax(_ data: SyntaxData) {
       let node = LabeledStmtSyntax(data)
@@ -6035,6 +6056,8 @@ open class SyntaxVisitor {
       visitImplBackDeployVersionListSyntax(data)
     case .backDeployVersionArgument:
       visitImplBackDeployVersionArgumentSyntax(data)
+    case .opaqueReturnTypeOfAttributeArguments:
+      visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(data)
     case .labeledStmt:
       visitImplLabeledStmtSyntax(data)
     case .continueStmt: