Revert "Merge pull request #1167 from hborla/pack-expansion-syntax"

This reverts commit d856f48, reversing
changes made to f5f45e2.

This PR requires non-trivial changes in apple/swift that we don’t want to cherry-pick to release/5.8.

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift

@@ -226,22 +226,6 @@ public let EXPR_NODES: [Node] = [
                ])
        ]),
 
-  Node(name: "PackExpansionExpr",
-       nameForDiagnostics: nil,
-       kind: "Expr",
-       children: [
-         Child(name: "RepeatKeyword",
-               kind: "KeywordToken",
-               tokenChoices: [
-                 "Keyword"
-               ],
-               textChoices: [
-                 "repeat"
-               ]),
-         Child(name: "PatternExpr",
-               kind: "Expr")
-       ]),
-
   Node(name: "PackElementExpr",
        nameForDiagnostics: nil,
        kind: "Expr",

CodeGeneration/Sources/SyntaxSupport/gyb_generated/TypeNodes.swift

@@ -207,16 +207,13 @@ public let TYPE_NODES: [Node] = [
        nameForDiagnostics: "variadic expansion",
        kind: "Type",
        children: [
-         Child(name: "RepeatKeyword",
-               kind: "KeywordToken",
-               tokenChoices: [
-                 "Keyword"
-               ],
-               textChoices: [
-                 "repeat"
-               ]),
          Child(name: "PatternType",
-               kind: "Type")
+               kind: "Type"),
+         Child(name: "Ellipsis",
+               kind: "EllipsisToken",
+               tokenChoices: [
+                 "Ellipsis"
+               ])
        ]),
 
   Node(name: "PackReferenceType",

Sources/SwiftParser/Expressions.swift

@@ -38,17 +38,6 @@ extension TokenConsumer {
         return true
       }
     }
-
-    // 'repeat' is the start of a pack expansion expression.
-    if (self.at(.keyword(.repeat))) {
-      // FIXME: 'repeat' followed by '{' could still be a pack
-      // expansion, but we need to do more lookahead to figure out
-      // whether the '{' is the start of a closure expression or a
-      // brace statement for 'repeat { ... } while'
-      let backtrack = self.lookahead()
-      return backtrack.peek().rawTokenKind != .leftBrace
-    }
-
     return false
   }
 }
@@ -476,14 +465,6 @@ extension Parser {
   ) -> RawExprSyntax {
     // First check to see if we have the start of a regex literal `/.../`.
     //    tryLexRegexLiteral(/*forUnappliedOperator*/ false)
-
-    // 'repeat' is the start of a pack expansion expression.
-    if (self.at(.keyword(.repeat))) {
-      return RawExprSyntax(
-        parsePackExpansionExpr(flavor, pattern: pattern)
-      )
-    }
-
     switch self.at(anyIn: ExpressionPrefixOperator.self) {
     case (.prefixAmpersand, let handle)?:
       let amp = self.eat(handle)
@@ -1156,7 +1137,7 @@ extension Parser {
         }
 
         if let each = self.consume(if: .keyword(.each)) {
-          let packRef = self.parseSequenceExpressionElement(flavor, pattern: pattern)
+          let packRef = self.parseExpression()
           return RawExprSyntax(
             RawPackElementExprSyntax(
               eachKeyword: each,
@@ -1342,31 +1323,6 @@ extension Parser {
   }
 }
 
-extension Parser {
-  /// Parse a pack expansion as an expression.
-  ///
-  ///
-  /// Grammar
-  /// =======
-  ///
-  /// pack-expansion-expression → 'repeat' pattern-expression
-  /// pattern-expression → expression
-  @_spi(RawSyntax)
-  public mutating func parsePackExpansionExpr(
-    _ flavor: ExprFlavor,
-    pattern: PatternContext
-  ) -> RawPackExpansionExprSyntax {
-    let repeatKeyword = self.consumeAnyToken()
-    let patternExpr = self.parseExpression(flavor, pattern: pattern)
-
-    return RawPackExpansionExprSyntax(
-      repeatKeyword: repeatKeyword,
-      patternExpr: patternExpr,
-      arena: self.arena
-    )
-  }
-}
-
 extension Parser {
   /// Parse a regular expression literal.
   ///

Sources/SwiftParser/Patterns.swift

@@ -373,7 +373,7 @@ extension Parser.Lookahead {
     // If the next token can be an argument label, we might have a name.
     if nextTok.canBeArgumentLabel(allowDollarIdentifier: true) {
       // If the first name wasn't "isolated", we're done.
-      if !self.at(.keyword(.isolated)) && !self.at(.keyword(.some)) && !self.at(.keyword(.any)) && !self.at(.keyword(.each)) && !self.at(.keyword(.repeat)) {
+      if !self.at(.keyword(.isolated)) && !self.at(.keyword(.some)) && !self.at(.keyword(.any)) && !self.at(.keyword(.each)) {
         return true
       }
 

Sources/SwiftParser/Statements.swift

@@ -1238,19 +1238,14 @@ extension Parser.Lookahead {
       .guardKeyword?,
       .whileKeyword?,
       .doKeyword?,
+      .repeatKeyword?,
       .forKeyword?,
       .breakKeyword?,
       .continueKeyword?,
       .fallthroughKeyword?,
       .switchKeyword?,
       .poundAssertKeyword?:
       return true
-    case .repeatKeyword?:
-      // 'repeat' followed by anything other than a brace stmt
-      // is a pack expansion expression.
-      // FIXME: 'repeat' followed by '{' could be a pack expansion
-      // with a closure pattern.
-      return self.peek().rawTokenKind == .leftBrace
     case .yield?:
       switch self.peek().rawTokenKind {
       case .prefixAmpersand:

Sources/SwiftParser/Types.swift

@@ -25,19 +25,20 @@ extension Parser {
   ///     type → opaque-type
   @_spi(RawSyntax)
   public mutating func parseType(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
-    // Parse pack expansion 'repeat T'.
-    if let repeatKeyword = self.consume(if: .keyword(.repeat)) {
-      let type = self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
+    let type = self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
+
+    // Parse pack expansion 'T...'.
+    if self.currentToken.isEllipsis {
+      let ellipsis = self.consumeAnyToken(remapping: .ellipsis)
       return RawTypeSyntax(
         RawPackExpansionTypeSyntax(
-          repeatKeyword: repeatKeyword,
           patternType: type,
+          ellipsis: ellipsis,
           arena: self.arena
         )
       )
     }
-
-    return self.parseTypeScalar(misplacedSpecifiers: misplacedSpecifiers)
+    return type
   }
 
   mutating func parseTypeScalar(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
@@ -671,9 +672,6 @@ extension Parser.Lookahead {
   }
 
   mutating func canParseTypeScalar() -> Bool {
-    // 'repeat' starts a pack expansion type
-    self.consume(if: .keyword(.repeat))
-
     self.skipTypeAttributeList()
 
     guard self.canParseSimpleOrCompositionType() else {
@@ -699,7 +697,11 @@ extension Parser.Lookahead {
   }
 
   mutating func canParseSimpleOrCompositionType() -> Bool {
-    if self.at(.keyword(.some)) || self.at(.keyword(.any)) || self.at(.keyword(.each)) {
+    if self.at(.keyword(.each)) {
+      return self.canParseSimpleType();
+    }
+
+    if self.at(.keyword(.some)) || self.at(.keyword(.any)) {
       self.consumeAnyToken()
     }
 
@@ -746,8 +748,6 @@ extension Parser.Lookahead {
       }
     case .wildcard:
       self.consumeAnyToken()
-    case .keyword(.repeat):
-      return true
     default:
       return false
     }

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

@@ -116,7 +116,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/NilLiteralExprSyntax>
 - <doc:SwiftSyntax/DiscardAssignmentExprSyntax>
 - <doc:SwiftSyntax/AssignmentExprSyntax>
-- <doc:SwiftSyntax/PackExpansionExprSyntax>
 - <doc:SwiftSyntax/PackElementExprSyntax>
 - <doc:SwiftSyntax/SequenceExprSyntax>
 - <doc:SwiftSyntax/PrefixOperatorExprSyntax>

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, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packExpansionExpr, .packElementExpr, .sequenceExpr, .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, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .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
     }
   }
@@ -1693,66 +1693,6 @@ public struct RawAssignmentExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
-@_spi(RawSyntax)
-public struct RawPackExpansionExprSyntax: RawExprSyntaxNodeProtocol {
-
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .packExpansionExpr
-  }
-
-  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(
-    _ unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? = nil,
-    repeatKeyword: RawTokenSyntax,
-    _ unexpectedBetweenRepeatKeywordAndPatternExpr: RawUnexpectedNodesSyntax? = nil,
-    patternExpr: RawExprSyntax,
-    _ unexpectedAfterPatternExpr: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .packExpansionExpr, uninitializedCount: 5, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeRepeatKeyword?.raw
-      layout[1] = repeatKeyword.raw
-      layout[2] = unexpectedBetweenRepeatKeywordAndPatternExpr?.raw
-      layout[3] = patternExpr.raw
-      layout[4] = unexpectedAfterPatternExpr?.raw
-    }
-    self.init(raw: raw)
-  }
-
-  public var unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var repeatKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenRepeatKeywordAndPatternExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var patternExpr: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw:))!
-  }
-  public var unexpectedAfterPatternExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-}
-
 @_spi(RawSyntax)
 public struct RawPackElementExprSyntax: RawExprSyntaxNodeProtocol {
 
@@ -16962,38 +16902,38 @@ public struct RawPackExpansionTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
 
   public init(
-    _ unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? = nil,
-    repeatKeyword: RawTokenSyntax,
-    _ unexpectedBetweenRepeatKeywordAndPatternType: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedBeforePatternType: RawUnexpectedNodesSyntax? = nil,
     patternType: RawTypeSyntax,
-    _ unexpectedAfterPatternType: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedBetweenPatternTypeAndEllipsis: RawUnexpectedNodesSyntax? = nil,
+    ellipsis: RawTokenSyntax,
+    _ unexpectedAfterEllipsis: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
       kind: .packExpansionType, uninitializedCount: 5, arena: arena) { layout in
       layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeRepeatKeyword?.raw
-      layout[1] = repeatKeyword.raw
-      layout[2] = unexpectedBetweenRepeatKeywordAndPatternType?.raw
-      layout[3] = patternType.raw
-      layout[4] = unexpectedAfterPatternType?.raw
+      layout[0] = unexpectedBeforePatternType?.raw
+      layout[1] = patternType.raw
+      layout[2] = unexpectedBetweenPatternTypeAndEllipsis?.raw
+      layout[3] = ellipsis.raw
+      layout[4] = unexpectedAfterEllipsis?.raw
     }
     self.init(raw: raw)
   }
 
-  public var unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforePatternType: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  public var repeatKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  public var patternType: RawTypeSyntax {
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
-  public var unexpectedBetweenRepeatKeywordAndPatternType: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenPatternTypeAndEllipsis: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  public var patternType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
+  public var ellipsis: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
-  public var unexpectedAfterPatternType: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterEllipsis: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -278,14 +278,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     break
-  case .packExpansionExpr:
-    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 .packElementExpr:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -2469,9 +2461,9 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
   case .packExpansionType:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTypeSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     break
   case .packReferenceType: