Merge pull request #1680 from gottesmm/release-5.9-copy-consume

[5.9] Add support for the copy operator and fix parsing issues around consume

Author: gottesmm

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -1126,7 +1126,7 @@ public let EXPR_NODES: [Node] = [
   // The move expr
   Node(
     name: "MoveExpr",
-    nameForDiagnostics: "'_move' expression",
+    nameForDiagnostics: "'consume' expression",
     kind: "Expr",
     children: [
       Child(
@@ -1140,6 +1140,22 @@ public let EXPR_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    name: "CopyExpr",
+    nameForDiagnostics: "'copy' expression",
+    kind: "Expr",
+    children: [
+      Child(
+        name: "CopyKeyword",
+        kind: .token(choices: [.keyword(text: "copy")])
+      ),
+      Child(
+        name: "Expression",
+        kind: .node(kind: "Expr")
+      ),
+    ]
+  ),
+
   Node(
     name: "MultipleTrailingClosureElementList",
     nameForDiagnostics: nil,

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -106,6 +106,7 @@ public let KEYWORDS: [KeywordSpec] = [
   KeywordSpec("catch", isLexerClassified: true, requiresLeadingSpace: true),
   KeywordSpec("class", isLexerClassified: true, requiresTrailingSpace: true),
   KeywordSpec("consume"),
+  KeywordSpec("copy"),
   KeywordSpec("consuming"),
   KeywordSpec("continue", isLexerClassified: true, requiresTrailingSpace: true),
   KeywordSpec("convenience"),

Sources/SwiftParser/Expressions.swift

@@ -411,7 +411,7 @@ extension Parser {
       }
     }
 
-    switch self.at(anyIn: AwaitTryMove.self) {
+    EXPR_PREFIX: switch self.at(anyIn: ExpressionModifierKeyword.self) {
     case (.awaitKeyword, let handle)?:
       let awaitTok = self.eat(handle)
       let sub = self.parseSequenceExpressionElement(
@@ -472,18 +472,48 @@ extension Parser {
         )
       )
 
+    case (.copyKeyword, let handle)?:
+      // `copy` is only contextually a keyword, if it's followed by an
+      // identifier or keyword on the same line. We do this to ensure that we do
+      // not break any copy functions defined by users. This is following with
+      // what we have done for the consume keyword.
+      switch self.peek() {
+      case TokenSpec(.identifier, allowAtStartOfLine: false),
+        TokenSpec(.dollarIdentifier, allowAtStartOfLine: false),
+        TokenSpec(.self, allowAtStartOfLine: false):
+        break
+      default:
+        // Break out of `outer switch` on failure.
+        break EXPR_PREFIX
+      }
+
+      let copyTok = self.eat(handle)
+      let sub = self.parseSequenceExpressionElement(
+        flavor,
+        forDirective: forDirective,
+        pattern: pattern
+      )
+      return RawExprSyntax(
+        RawCopyExprSyntax(
+          copyKeyword: copyTok,
+          expression: sub,
+          arena: self.arena
+        )
+      )
+
     case (.consumeKeyword, let handle)?:
       // `consume` is only contextually a keyword, if it's followed by an
-      // identifier or keyword on the same line.
-      let next = peek()
-      if next.isAtStartOfLine {
-        fallthrough
-      }
-      if next.rawTokenKind != .identifier,
-        next.rawTokenKind != .dollarIdentifier,
-        next.rawTokenKind != .keyword
-      {
-        fallthrough
+      // identifier or keyword on the same line. We do this to ensure that we do
+      // not break any copy functions defined by users. This is following with
+      // what we have done for the consume keyword.
+      switch self.peek() {
+      case TokenSpec(.identifier, allowAtStartOfLine: false),
+        TokenSpec(.dollarIdentifier, allowAtStartOfLine: false),
+        TokenSpec(.self, allowAtStartOfLine: false):
+        break
+      default:
+        // Break out of the outer `switch`.
+        break EXPR_PREFIX
       }
 
       let consumeTok = self.eat(handle)
@@ -500,8 +530,9 @@ extension Parser {
         )
       )
     case nil:
-      return self.parseUnaryExpression(flavor, forDirective: forDirective, pattern: pattern)
+      break
     }
+    return self.parseUnaryExpression(flavor, forDirective: forDirective, pattern: pattern)
   }
 
   /// Parse an optional prefix operator followed by an expression.

Sources/SwiftParser/TokenSpecSet.swift

@@ -452,12 +452,13 @@ public enum TypeSpecifier: TokenSpecSet {
 
 // MARK: Expression start
 
-enum AwaitTryMove: TokenSpecSet {
+enum ExpressionModifierKeyword: TokenSpecSet {
   case awaitKeyword
   case _moveKeyword
   case _borrowKeyword
   case tryKeyword
   case consumeKeyword
+  case copyKeyword
 
   init?(lexeme: Lexer.Lexeme) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -466,6 +467,7 @@ enum AwaitTryMove: TokenSpecSet {
     case TokenSpec(._borrow): self = ._borrowKeyword
     case TokenSpec(.try): self = .tryKeyword
     case TokenSpec(.consume): self = .consumeKeyword
+    case TokenSpec(.copy): self = .copyKeyword
     default: return nil
     }
   }
@@ -476,6 +478,7 @@ enum AwaitTryMove: TokenSpecSet {
     case ._moveKeyword: return .keyword(._move)
     case ._borrowKeyword: return .keyword(._borrow)
     case .consumeKeyword: return .keyword(.consume)
+    case .copyKeyword: return .keyword(.copy)
     case .tryKeyword: return .keyword(.try)
     }
   }
@@ -668,13 +671,13 @@ enum PrimaryExpressionStart: TokenSpecSet {
 ///  - `MatchingPatternStart`
 ///  - `PrimaryExpressionStart`
 enum ExpressionStart: TokenSpecSet {
-  case awaitTryMove(AwaitTryMove)
+  case awaitTryMove(ExpressionModifierKeyword)
   case expressionPrefixOperator(ExpressionPrefixOperator)
   case primaryExpressionStart(PrimaryExpressionStart)
   case ifOrSwitch(IfOrSwitch)
 
   init?(lexeme: Lexer.Lexeme) {
-    if let subset = AwaitTryMove(lexeme: lexeme) {
+    if let subset = ExpressionModifierKeyword(lexeme: lexeme) {
       self = .awaitTryMove(subset)
     } else if let subset = ExpressionPrefixOperator(lexeme: lexeme) {
       self = .expressionPrefixOperator(subset)
@@ -688,7 +691,7 @@ enum ExpressionStart: TokenSpecSet {
   }
 
   static var allCases: [ExpressionStart] {
-    return AwaitTryMove.allCases.map(Self.awaitTryMove)
+    return ExpressionModifierKeyword.allCases.map(Self.awaitTryMove)
       + ExpressionPrefixOperator.allCases.map(Self.expressionPrefixOperator)
       + PrimaryExpressionStart.allCases.map(Self.primaryExpressionStart)
       + IfOrSwitch.allCases.map(Self.ifOrSwitch)

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -107,6 +107,8 @@ extension SyntaxKind {
       return "@convention(...) arguments"
     case .conventionWitnessMethodAttributeArguments:
       return "@convention(...) arguments for witness methods"
+    case .copyExpr:
+      return "'copy' expression"
     case .declModifier:
       return "modifier"
     case .declName:
@@ -270,7 +272,7 @@ extension SyntaxKind {
     case .missingType:
       return "type"
     case .moveExpr:
-      return "'_move' expression"
+      return "'consume' expression"
     case .multipleTrailingClosureElement:
       return "trailing closure"
     case .namedOpaqueReturnType:

Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md

@@ -94,6 +94,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/BooleanLiteralExprSyntax>
 - <doc:SwiftSyntax/BorrowExprSyntax>
 - <doc:SwiftSyntax/ClosureExprSyntax>
+- <doc:SwiftSyntax/CopyExprSyntax>
 - <doc:SwiftSyntax/DictionaryExprSyntax>
 - <doc:SwiftSyntax/DiscardAssignmentExprSyntax>
 - <doc:SwiftSyntax/EditorPlaceholderExprSyntax>

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -757,6 +757,16 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "protocolName"
   case \ConventionWitnessMethodAttributeArgumentsSyntax.unexpectedAfterProtocolName:
     return "unexpectedAfterProtocolName"
+  case \CopyExprSyntax.unexpectedBeforeCopyKeyword:
+    return "unexpectedBeforeCopyKeyword"
+  case \CopyExprSyntax.copyKeyword:
+    return "copyKeyword"
+  case \CopyExprSyntax.unexpectedBetweenCopyKeywordAndExpression:
+    return "unexpectedBetweenCopyKeywordAndExpression"
+  case \CopyExprSyntax.expression:
+    return "expression"
+  case \CopyExprSyntax.unexpectedAfterExpression:
+    return "unexpectedAfterExpression"
   case \DeclModifierDetailSyntax.unexpectedBeforeLeftParen:
     return "unexpectedBeforeLeftParen"
   case \DeclModifierDetailSyntax.leftParen:

Sources/SwiftSyntax/generated/Keyword.swift

@@ -83,6 +83,7 @@ public enum Keyword: UInt8, Hashable {
   case `catch`
   case `class`
   case consume
+  case copy
   case consuming
   case `continue`
   case convenience
@@ -265,6 +266,8 @@ public enum Keyword: UInt8, Hashable {
         self = ._spi
       case "case":
         self = .`case`
+      case "copy":
+        self = .copy
       case "each":
         self = .each
       case "else":
@@ -806,6 +809,7 @@ public enum Keyword: UInt8, Hashable {
       "catch", 
       "class", 
       "consume", 
+      "copy", 
       "consuming", 
       "continue", 
       "convenience", 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

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

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -206,7 +206,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .copyExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -218,7 +218,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .copyExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
       break
     default:
       preconditionFailure("Unable to create ExprSyntax from \(data.raw.kind)")
@@ -263,6 +263,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
           .node(BooleanLiteralExprSyntax.self),
           .node(BorrowExprSyntax.self),
           .node(ClosureExprSyntax.self),
+          .node(CopyExprSyntax.self),
           .node(DictionaryExprSyntax.self),
           .node(DiscardAssignmentExprSyntax.self),
           .node(EditorPlaceholderExprSyntax.self),
@@ -749,6 +750,7 @@ extension Syntax {
           .node(ContinueStmtSyntax.self),
           .node(ConventionAttributeArgumentsSyntax.self),
           .node(ConventionWitnessMethodAttributeArgumentsSyntax.self),
+          .node(CopyExprSyntax.self),
           .node(DeclModifierDetailSyntax.self),
           .node(DeclModifierSyntax.self),
           .node(DeclNameArgumentListSyntax.self),