[borrow-expr] Initial commit for borrow expo

CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift

@@ -111,6 +111,22 @@ public let EXPR_NODES: [Node] = [
                kind: "Expr")
        ]),
 
+  Node(name: "BorrowExpr",
+       nameForDiagnostics: "'_borrow' expression",
+       kind: "Expr",
+       children: [
+         Child(name: "BorrowKeyword",
+               kind: "ContextualKeywordToken",
+               tokenChoices: [
+                 "ContextualKeyword"
+               ],
+               textChoices: [
+                 "_borrow"
+               ]),
+         Child(name: "Expression",
+               kind: "Expr")
+       ]),
+
   Node(name: "DeclNameArgument",
        nameForDiagnostics: nil,
        kind: "Syntax",

Sources/SwiftParser/Expressions.swift

@@ -465,6 +465,20 @@ extension Parser {
           arena: self.arena
         )
       )
+    case (._borrowContextualKeyword, let handle)?:
+      let borrowTok = self.eat(handle)
+      let sub = self.parseSequenceExpressionElement(
+        flavor,
+        forDirective: forDirective,
+        pattern: pattern
+      )
+      return RawExprSyntax(
+        RawBorrowExprSyntax(
+          borrowKeyword: borrowTok,
+          expression: sub,
+          arena: self.arena
+        )
+      )
     case nil:
       return self.parseUnaryExpression(flavor, forDirective: forDirective, pattern: pattern)
     }

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -583,13 +583,15 @@ public enum TypeSpecifier: RawTokenKindSubset {
 enum AwaitTryMove: RawTokenKindSubset {
   case awaitContextualKeyword
   case _moveContextualKeyword
+  case _borrowContextualKeyword
   case tryKeyword
 
   init?(lexeme: Lexer.Lexeme) {
     switch (lexeme.tokenKind, lexeme.tokenText) {
     case (.tryKeyword, _): self = .tryKeyword
     case (.identifier, "await"): self = .awaitContextualKeyword
     case (.identifier, "_move"): self = ._moveContextualKeyword
+    case (.identifier, "_borrow"): self = ._borrowContextualKeyword
     default: return nil
     }
   }
@@ -598,6 +600,7 @@ enum AwaitTryMove: RawTokenKindSubset {
     switch self {
     case .awaitContextualKeyword: return .identifier
     case ._moveContextualKeyword: return .identifier
+    case ._borrowContextualKeyword: return .identifier
     case .tryKeyword: return .tryKeyword
     }
   }
@@ -606,6 +609,7 @@ enum AwaitTryMove: RawTokenKindSubset {
     switch self {
     case .awaitContextualKeyword: return "await"
     case ._moveContextualKeyword: return "_move"
+    case ._borrowContextualKeyword: return "_borrow"
     default: return nil
     }
   }

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

@@ -107,6 +107,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/TryExprSyntax>
 - <doc:SwiftSyntax/AwaitExprSyntax>
 - <doc:SwiftSyntax/MoveExprSyntax>
+- <doc:SwiftSyntax/BorrowExprSyntax>
 - <doc:SwiftSyntax/IdentifierExprSyntax>
 - <doc:SwiftSyntax/SuperRefExprSyntax>
 - <doc:SwiftSyntax/NilLiteralExprSyntax>

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -65,7 +65,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true
+    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true
     default: return false
     }
   }
@@ -1155,6 +1155,66 @@ public struct RawMoveExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawBorrowExprSyntax: RawExprSyntaxNodeProtocol {
+
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .borrowExpr
+  }
+
+  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(
+    _ unexpectedBeforeBorrowKeyword: RawUnexpectedNodesSyntax? = nil,
+    borrowKeyword: RawTokenSyntax,
+    _ unexpectedBetweenBorrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil,
+    expression: RawExprSyntax,
+    _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .borrowExpr, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeBorrowKeyword?.raw
+      layout[1] = borrowKeyword.raw
+      layout[2] = unexpectedBetweenBorrowKeywordAndExpression?.raw
+      layout[3] = expression.raw
+      layout[4] = unexpectedAfterExpression?.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeBorrowKeyword: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var borrowKeyword: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenBorrowKeywordAndExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var expression: RawExprSyntax {
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
+  }
+  public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawDeclNameArgumentSyntax: RawSyntaxNodeProtocol {
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -209,6 +209,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     break
+  case .borrowExpr:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    break
   case .declNameArgument:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/Misc.swift

@@ -51,6 +51,7 @@ extension Syntax {
       .node(BackDeployVersionListSyntax.self), 
       .node(BinaryOperatorExprSyntax.self), 
       .node(BooleanLiteralExprSyntax.self), 
+      .node(BorrowExprSyntax.self), 
       .node(BreakStmtSyntax.self), 
       .node(CaseItemListSyntax.self), 
       .node(CaseItemSyntax.self), 
@@ -354,6 +355,8 @@ extension SyntaxKind {
       return BinaryOperatorExprSyntax.self
     case .booleanLiteralExpr: 
       return BooleanLiteralExprSyntax.self
+    case .borrowExpr: 
+      return BorrowExprSyntax.self
     case .breakStmt: 
       return BreakStmtSyntax.self
     case .caseItemList: 
@@ -887,6 +890,8 @@ extension SyntaxKind {
       return nil
     case .booleanLiteralExpr: 
       return "bool literal"
+    case .borrowExpr: 
+      return "'_borrow' expression"
     case .breakStmt: 
       return "'break' statement"
     case .caseItemList: 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -313,6 +313,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: BorrowExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: BorrowExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: BreakStmtSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -218,7 +218,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init? < S: SyntaxProtocol > (_ node: S) {
     switch node.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
       self._syntaxNode = node._syntaxNode
     default: 
       return nil
@@ -231,7 +231,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
       break 
     default: 
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")
@@ -274,6 +274,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
       .node(AwaitExprSyntax.self), 
       .node(BinaryOperatorExprSyntax.self), 
       .node(BooleanLiteralExprSyntax.self), 
+      .node(BorrowExprSyntax.self), 
       .node(ClosureExprSyntax.self), 
       .node(DictionaryExprSyntax.self), 
       .node(DiscardAssignmentExprSyntax.self), 

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -82,6 +82,8 @@ public enum SyntaxEnum {
 
   case booleanLiteralExpr(BooleanLiteralExprSyntax)
 
+  case borrowExpr(BorrowExprSyntax)
+
   case breakStmt(BreakStmtSyntax)
 
   case caseItemList(CaseItemListSyntax)
@@ -615,6 +617,8 @@ public extension Syntax {
       return .binaryOperatorExpr(BinaryOperatorExprSyntax(self)!)
     case .booleanLiteralExpr: 
       return .booleanLiteralExpr(BooleanLiteralExprSyntax(self)!)
+    case .borrowExpr: 
+      return .borrowExpr(BorrowExprSyntax(self)!)
     case .breakStmt: 
       return .breakStmt(BreakStmtSyntax(self)!)
     case .caseItemList: 

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -82,6 +82,8 @@ public enum SyntaxKind {
 
   case booleanLiteralExpr
 
+  case borrowExpr
+
   case breakStmt
 
   case caseItemList

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -467,6 +467,37 @@ public enum SyntaxFactory {
       return MoveExprSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on BorrowExprSyntax")
+  public static func makeBorrowExpr(_ unexpectedBeforeBorrowKeyword: UnexpectedNodesSyntax? = nil, borrowKeyword: TokenSyntax, _ unexpectedBetweenBorrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil) -> BorrowExprSyntax {
+    let layout: [RawSyntax?] = [
+      unexpectedBeforeBorrowKeyword?.raw,
+      borrowKeyword.raw,
+      unexpectedBetweenBorrowKeywordAndExpression?.raw,
+      expression.raw,
+      unexpectedAfterExpression?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.borrowExpr,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return BorrowExprSyntax(data)
+    }
+  }
+
+  @available(*, deprecated, message: "Use initializer on BorrowExprSyntax")
+  public static func makeBlankBorrowExpr(presence: SourcePresence = .present) -> BorrowExprSyntax {
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .borrowExpr,
+        from: [
+        nil,
+        RawSyntax.makeMissingToken(kind: TokenKind.contextualKeyword(""), arena: arena),
+        nil,
+        RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena),
+        nil,
+      ], arena: arena))
+      return BorrowExprSyntax(data)
+    }
+  }
   @available(*, deprecated, message: "Use initializer on DeclNameArgumentSyntax")
   public static func makeDeclNameArgument(_ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> DeclNameArgumentSyntax {
     let layout: [RawSyntax?] = [

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -156,6 +156,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `BorrowExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: BorrowExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `DeclNameArgumentSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2128,6 +2135,16 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplBorrowExprSyntax(_ data: SyntaxData) -> Syntax {
+    let node = BorrowExprSyntax(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 Syntax(visit(node))
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplDeclNameArgumentSyntax(_ data: SyntaxData) -> Syntax {
     let node = DeclNameArgumentSyntax(data)
@@ -4646,6 +4663,8 @@ open class SyntaxRewriter {
       return visitImplAwaitExprSyntax
     case .moveExpr:
       return visitImplMoveExprSyntax
+    case .borrowExpr:
+      return visitImplBorrowExprSyntax
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax
     case .declNameArgumentList:
@@ -5185,6 +5204,8 @@ open class SyntaxRewriter {
       return visitImplAwaitExprSyntax(data)
     case .moveExpr:
       return visitImplMoveExprSyntax(data)
+    case .borrowExpr:
+      return visitImplBorrowExprSyntax(data)
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax(data)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift

@@ -95,6 +95,10 @@ public protocol SyntaxTransformVisitor {
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: MoveExprSyntax) -> ResultType
+  /// Visiting `BorrowExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: BorrowExprSyntax) -> ResultType
   /// Visiting `DeclNameArgumentSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -1192,6 +1196,12 @@ extension SyntaxTransformVisitor {
   public func visit(_ node: MoveExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
+  /// Visiting `BorrowExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: BorrowExprSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
   /// Visiting `DeclNameArgumentSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -2699,6 +2709,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .moveExpr(let derived):
       return visit(derived)
+    case .borrowExpr(let derived):
+      return visit(derived)
     case .declNameArgument(let derived):
       return visit(derived)
     case .declNameArgumentList(let derived):