Parse Move Expressions

Author: CodaFi

Sources/SwiftParser/Expressions.swift

@@ -317,10 +317,11 @@ extension Parser {
       }
     }
 
-    switch self.at(anyIn: AwaitTry.self) {
+    switch self.at(anyIn: AwaitTryMove.self) {
     case (.awaitContextualKeyword, let handle)?:
       let awaitTok = self.eat(handle)
-      let sub = self.parseSequenceExpressionElement(flavor, inVarOrLet: inVarOrLet)
+      let sub = self.parseSequenceExpressionElement(
+        flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
       return RawExprSyntax(RawAwaitExprSyntax(
         awaitKeyword: awaitTok,
         expression: sub,
@@ -330,13 +331,22 @@ extension Parser {
       let tryKeyword = self.eat(handle)
       let mark = self.consume(ifAny: [.exclamationMark, .postfixQuestionMark])
 
-      let expression = self.parseSequenceExpressionElement(flavor, inVarOrLet: inVarOrLet)
+      let expression = self.parseSequenceExpressionElement(
+        flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
       return RawExprSyntax(RawTryExprSyntax(
         tryKeyword: tryKeyword,
         questionOrExclamationMark: mark,
         expression: expression,
         arena: self.arena
       ))
+    case (._moveContextualKeyword, let handle)?:
+      let moveTok = self.eat(handle)
+      let sub = self.parseSequenceExpressionElement(
+        flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
+      return RawExprSyntax(RawMoveExprSyntax(
+        moveKeyword: moveTok,
+        expression: sub,
+        arena: self.arena))
     case nil:
       return self.parseUnaryExpression(flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
     }

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -433,20 +433,23 @@ enum SwitchCaseStart: RawTokenKindSubset {
 
 // MARK: Expression start
 
-enum AwaitTry: RawTokenKindSubset {
+enum AwaitTryMove: RawTokenKindSubset {
   case awaitContextualKeyword
+  case _moveContextualKeyword
   case tryKeyword
 
   var rawTokenKind: RawTokenKind {
     switch self {
     case .awaitContextualKeyword: return .identifier
+    case ._moveContextualKeyword: return .identifier
     case .tryKeyword: return .tryKeyword
     }
   }
 
   var contextualKeyword: SyntaxText? {
     switch self {
     case .awaitContextualKeyword: return "await"
+    case ._moveContextualKeyword: return "_move"
     default: return nil
     }
   }
@@ -573,21 +576,21 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
 ///  - `MatchingPatternStart`
 ///  - `PrimaryExpressionStart`
 enum ExpressionStart: RawTokenKindSubset {
-  case awaitTry(AwaitTry)
+  case awaitTryMove(AwaitTryMove)
   case expressionPrefixOperator(ExpressionPrefixOperator)
   case matchingPatternStart(MatchingPatternStart)
   case primaryExpressionStart(PrimaryExpressionStart)
 
   static var allCases: [ExpressionStart] {
-    return AwaitTry.allCases.map(Self.awaitTry)
+    return AwaitTryMove.allCases.map(Self.awaitTryMove)
     + ExpressionPrefixOperator.allCases.map(Self.expressionPrefixOperator)
     + MatchingPatternStart.allCases.map(Self.matchingPatternStart)
     + PrimaryExpressionStart.allCases.map(Self.primaryExpressionStart)
   }
 
   var rawTokenKind: RawTokenKind {
     switch self {
-    case .awaitTry(let underlyingKind): return underlyingKind.rawTokenKind
+    case .awaitTryMove(let underlyingKind): return underlyingKind.rawTokenKind
     case .expressionPrefixOperator(let underlyingKind): return underlyingKind.rawTokenKind
     case .matchingPatternStart(let underlyingKind): return underlyingKind.rawTokenKind
     case .primaryExpressionStart(let underlyingKind): return underlyingKind.rawTokenKind
@@ -596,7 +599,7 @@ enum ExpressionStart: RawTokenKindSubset {
 
   var contextualKeyword: SyntaxText? {
     switch self {
-    case .awaitTry(let underlyingKind): return underlyingKind.contextualKeyword
+    case .awaitTryMove(let underlyingKind): return underlyingKind.contextualKeyword
     case .expressionPrefixOperator(let underlyingKind): return underlyingKind.contextualKeyword
     case .matchingPatternStart(let underlyingKind): return underlyingKind.contextualKeyword
     case .primaryExpressionStart(let underlyingKind): return underlyingKind.contextualKeyword

Tests/SwiftParserTest/Expressions.swift

@@ -495,4 +495,11 @@ final class ExpressionTests: XCTestCase {
   func testTypeExpression() {
     AssertParse("_ = (any Sequence<Int>).self")
   }
+
+  func testMoveExpression() {
+    AssertParse("_move msg")
+    AssertParse("use(_move msg)")
+    AssertParse("_move msg")
+    AssertParse("let b = (_move self).buffer")
+  }
 }