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),

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -81,6 +81,7 @@ public enum SyntaxEnum {
   case continueStmt(ContinueStmtSyntax)
   case conventionAttributeArguments(ConventionAttributeArgumentsSyntax)
   case conventionWitnessMethodAttributeArguments(ConventionWitnessMethodAttributeArgumentsSyntax)
+  case copyExpr(CopyExprSyntax)
   case declModifierDetail(DeclModifierDetailSyntax)
   case declModifier(DeclModifierSyntax)
   case declNameArgumentList(DeclNameArgumentListSyntax)
@@ -423,6 +424,8 @@ public extension Syntax {
       return .conventionAttributeArguments(ConventionAttributeArgumentsSyntax(self)!)
     case .conventionWitnessMethodAttributeArguments:
       return .conventionWitnessMethodAttributeArguments(ConventionWitnessMethodAttributeArgumentsSyntax(self)!)
+    case .copyExpr:
+      return .copyExpr(CopyExprSyntax(self)!)
     case .declModifierDetail:
       return .declModifierDetail(DeclModifierDetailSyntax(self)!)
     case .declModifier:

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -81,6 +81,7 @@ public enum SyntaxKind {
   case continueStmt
   case conventionAttributeArguments
   case conventionWitnessMethodAttributeArguments
+  case copyExpr
   case declModifierDetail
   case declModifier
   case declNameArgumentList
@@ -538,6 +539,8 @@ public enum SyntaxKind {
       return ConventionAttributeArgumentsSyntax.self
     case .conventionWitnessMethodAttributeArguments:
       return ConventionWitnessMethodAttributeArgumentsSyntax.self
+    case .copyExpr:
+      return CopyExprSyntax.self
     case .declModifierDetail:
       return DeclModifierDetailSyntax.self
     case .declModifier:

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -480,6 +480,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node)).cast(ConventionWitnessMethodAttributeArgumentsSyntax.self)
   }
 
+  /// Visit a `CopyExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: CopyExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+  
   /// Visit a `DeclModifierDetailSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2892,6 +2899,20 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplCopyExprSyntax(_ data: SyntaxData) -> Syntax {
+    let node = CopyExprSyntax(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 visitImplDeclModifierDetailSyntax(_ data: SyntaxData) -> Syntax {
     let node = DeclModifierDetailSyntax(data)
@@ -5920,6 +5941,8 @@ open class SyntaxRewriter {
       return visitImplConventionAttributeArgumentsSyntax
     case .conventionWitnessMethodAttributeArguments:
       return visitImplConventionWitnessMethodAttributeArgumentsSyntax
+    case .copyExpr:
+      return visitImplCopyExprSyntax
     case .declModifierDetail:
       return visitImplDeclModifierDetailSyntax
     case .declModifier:
@@ -6468,6 +6491,8 @@ open class SyntaxRewriter {
       return visitImplConventionAttributeArgumentsSyntax(data)
     case .conventionWitnessMethodAttributeArguments:
       return visitImplConventionWitnessMethodAttributeArgumentsSyntax(data)
+    case .copyExpr:
+      return visitImplCopyExprSyntax(data)
     case .declModifierDetail:
       return visitImplDeclModifierDetailSyntax(data)
     case .declModifier: