Update swift-syntax for MoveExpr.

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -157,6 +157,12 @@ extension SyntaxNode {
     return AwaitExprSyntax(asSyntaxData)
   }
 
+  public var isMoveExpr: Bool { return raw.kind == .moveExpr }
+  public var asMoveExpr: MoveExprSyntax? {
+    guard isMoveExpr else { return nil }
+    return MoveExprSyntax(asSyntaxData)
+  }
+
   public var isDeclNameArgument: Bool { return raw.kind == .declNameArgument }
   public var asDeclNameArgument: DeclNameArgumentSyntax? {
     guard isDeclNameArgument else { return nil }
@@ -1637,6 +1643,8 @@ extension Syntax {
       return node
     case .awaitExpr(let node):
       return node
+    case .moveExpr(let node):
+      return node
     case .declNameArgument(let node):
       return node
     case .declNameArgumentList(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -222,6 +222,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: AwaitExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: MoveExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MoveExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: DeclNameArgumentSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -164,7 +164,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       self._syntaxNode = syntax
     default:
       return nil
@@ -178,7 +178,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -302,6 +302,52 @@ extension AwaitExprSyntax {
   }
 }
 
+public struct MoveExprSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 4)
+
+  internal init() {}
+
+  public mutating func useMoveKeyword(_ node: TokenSyntax) {
+    let idx = MoveExprSyntax.Cursor.moveKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useExpression(_ node: ExprSyntax) {
+    let idx = MoveExprSyntax.Cursor.expression.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.contextualKeyword(""))
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.missingExpr)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .moveExpr,
+      layout: layout, presence: .present))
+  }
+}
+
+extension MoveExprSyntax {
+  /// Creates a `MoveExprSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that will be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `MoveExprSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `MoveExprSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout MoveExprSyntaxBuilder) -> Void) {
+    var builder = MoveExprSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct DeclNameArgumentSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 4)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -39,6 +39,7 @@ public enum SyntaxEnum {
   case stringLiteralSegments(StringLiteralSegmentsSyntax)
   case tryExpr(TryExprSyntax)
   case awaitExpr(AwaitExprSyntax)
+  case moveExpr(MoveExprSyntax)
   case declNameArgument(DeclNameArgumentSyntax)
   case declNameArgumentList(DeclNameArgumentListSyntax)
   case declNameArguments(DeclNameArgumentsSyntax)
@@ -331,6 +332,8 @@ public extension Syntax {
       return .tryExpr(TryExprSyntax(self)!)
     case .awaitExpr:
       return .awaitExpr(AwaitExprSyntax(self)!)
+    case .moveExpr:
+      return .moveExpr(MoveExprSyntax(self)!)
     case .declNameArgument:
       return .declNameArgument(DeclNameArgumentSyntax(self)!)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -353,6 +353,29 @@ public enum SyntaxFactory {
     ], length: .zero, presence: presence))
     return AwaitExprSyntax(data)
   }
+  public static func makeMoveExpr(_ garbageBeforeMoveKeyword: GarbageNodesSyntax? = nil, moveKeyword: TokenSyntax, _ garbageBetweenMoveKeywordAndExpression: GarbageNodesSyntax? = nil, expression: ExprSyntax) -> MoveExprSyntax {
+    let layout: [RawSyntax?] = [
+      garbageBeforeMoveKeyword?.raw,
+      moveKeyword.raw,
+      garbageBetweenMoveKeywordAndExpression?.raw,
+      expression.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.moveExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return MoveExprSyntax(data)
+  }
+
+  public static func makeBlankMoveExpr(presence: SourcePresence = .present) -> MoveExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .moveExpr,
+      layout: [
+      nil,
+      RawSyntax.missingToken(TokenKind.contextualKeyword("")),
+      nil,
+      RawSyntax.missing(SyntaxKind.missingExpr),
+    ], length: .zero, presence: presence))
+    return MoveExprSyntax(data)
+  }
   public static func makeDeclNameArgument(_ garbageBeforeName: GarbageNodesSyntax? = nil, name: TokenSyntax, _ garbageBetweenNameAndColon: GarbageNodesSyntax? = nil, colon: TokenSyntax) -> DeclNameArgumentSyntax {
     let layout: [RawSyntax?] = [
       garbageBeforeName?.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -39,6 +39,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case stringLiteralSegments = 168
   case tryExpr = 27
   case awaitExpr = 249
+  case moveExpr = 269
   case declNameArgument = 94
   case declNameArgumentList = 169
   case declNameArguments = 95

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -184,6 +184,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `MoveExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: MoveExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `DeclNameArgumentSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2157,6 +2164,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplMoveExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = MoveExprSyntax(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)
@@ -4615,6 +4632,8 @@ open class SyntaxRewriter {
       return visitImplTryExprSyntax
     case .awaitExpr:
       return visitImplAwaitExprSyntax
+    case .moveExpr:
+      return visitImplMoveExprSyntax
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax
     case .declNameArgumentList:
@@ -5148,6 +5167,8 @@ open class SyntaxRewriter {
       return visitImplTryExprSyntax(data)
     case .awaitExpr:
       return visitImplAwaitExprSyntax(data)
+    case .moveExpr:
+      return visitImplMoveExprSyntax(data)
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax(data)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -271,6 +271,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `AwaitExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: AwaitExprSyntax) {}
+  /// Visiting `MoveExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: MoveExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `MoveExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: MoveExprSyntax) {}
   /// Visiting `DeclNameArgumentSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2962,6 +2972,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplMoveExprSyntax(_ data: SyntaxData) {
+      let node = MoveExprSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplDeclNameArgumentSyntax(_ data: SyntaxData) {
       let node = DeclNameArgumentSyntax(data)
@@ -5624,6 +5645,8 @@ open class SyntaxVisitor {
       visitImplTryExprSyntax(data)
     case .awaitExpr:
       visitImplAwaitExprSyntax(data)
+    case .moveExpr:
+      visitImplMoveExprSyntax(data)
     case .declNameArgument:
       visitImplDeclNameArgumentSyntax(data)
     case .declNameArgumentList: