Remove TokenList as option for AvailabilityArgument

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/AvailabilityNodes.swift

@@ -36,9 +36,7 @@ public let AVAILABILITY_NODES: [Node] = [
                  Child(name: "AvailabilityVersionRestriction",
                        kind: "AvailabilityVersionRestriction"),
                  Child(name: "AvailabilityLabeledArgument",
-                       kind: "AvailabilityLabeledArgument"),
-                 Child(name: "TokenList",
-                       kind: "TokenList")
+                       kind: "AvailabilityLabeledArgument")
                ]),
          Child(name: "TrailingComma",
                kind: "CommaToken",

Sources/SwiftParser/Availability.swift

@@ -48,28 +48,6 @@ extension Parser {
             arena: self.arena
           )
         )
-
-        // Before continuing to parse the next specification, we check that it's
-        // also in the shorthand syntax and recover from it.
-        if keepGoing != nil,
-          let (_, handle) = self.at(anyIn: AvailabilityArgumentKind.self)
-        {
-          var tokens = [RawTokenSyntax]()
-          tokens.append(self.eat(handle))
-          var recoveryProgress = LoopProgressCondition()
-          while !self.at(any: [.eof, .comma, .rightParen]) && recoveryProgress.evaluate(currentToken) {
-            tokens.append(self.consumeAnyToken())
-          }
-          let syntax = RawTokenListSyntax(elements: tokens, arena: self.arena)
-          keepGoing = self.consume(if: .comma)
-          elements.append(
-            RawAvailabilityArgumentSyntax(
-              entry: .tokenList(syntax),
-              trailingComma: keepGoing,
-              arena: self.arena
-            )
-          )
-        }
       } while keepGoing != nil && availablityArgumentProgress.evaluate(currentToken)
     }
 
@@ -127,7 +105,7 @@ extension Parser {
 
     do {
       var loopProgressCondition = LoopProgressCondition()
-      while keepGoing != nil && loopProgressCondition.evaluate(currentToken) {
+      LOOP: while keepGoing != nil && loopProgressCondition.evaluate(currentToken) {
         let entry: RawAvailabilityArgumentSyntax.Entry
         switch self.at(anyIn: AvailabilityArgumentKind.self) {
         case (.message, let handle)?,
@@ -182,13 +160,7 @@ extension Parser {
           // 'labeled' argument part optional?
           entry = .token(argument)
         case nil:
-          // Not sure what this label is but, let's just eat it and
-          // keep going.
-          var tokens = [RawTokenSyntax]()
-          while !self.at(any: [.eof, .comma, .rightParen]) {
-            tokens.append(self.consumeAnyToken())
-          }
-          entry = .tokenList(RawTokenListSyntax(elements: tokens, arena: self.arena))
+          break LOOP
         }
 
         keepGoing = self.consume(if: .comma)

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -18086,18 +18086,16 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol {
     case `token`(RawTokenSyntax)
     case `availabilityVersionRestriction`(RawAvailabilityVersionRestrictionSyntax)
     case `availabilityLabeledArgument`(RawAvailabilityLabeledArgumentSyntax)
-    case `tokenList`(RawTokenListSyntax)
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return RawTokenSyntax.isKindOf(raw) || RawAvailabilityVersionRestrictionSyntax.isKindOf(raw) || RawAvailabilityLabeledArgumentSyntax.isKindOf(raw) || RawTokenListSyntax.isKindOf(raw)
+      return RawTokenSyntax.isKindOf(raw) || RawAvailabilityVersionRestrictionSyntax.isKindOf(raw) || RawAvailabilityLabeledArgumentSyntax.isKindOf(raw)
     }
 
     public var raw: RawSyntax {
       switch self {
       case .token(let node): return node.raw
       case .availabilityVersionRestriction(let node): return node.raw
       case .availabilityLabeledArgument(let node): return node.raw
-      case .tokenList(let node): return node.raw
       }
     }
 
@@ -18114,10 +18112,6 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol {
         self = .availabilityLabeledArgument(node)
         return
       }
-      if let node = RawTokenListSyntax(other) {
-        self = .tokenList(node)
-        return
-      }
       return nil
     }
   }

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -2637,7 +2637,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
       verify(layout[1], as: RawSyntax.self),
       verify(layout[1], as: RawSyntax.self),
       verify(layout[1], as: RawSyntax.self),
-      verify(layout[1], as: RawSyntax.self),
     ])
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self))

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -26734,13 +26734,11 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     case `token`(TokenSyntax)
     case `availabilityVersionRestriction`(AvailabilityVersionRestrictionSyntax)
     case `availabilityLabeledArgument`(AvailabilityLabeledArgumentSyntax)
-    case `tokenList`(TokenListSyntax)
     public var _syntaxNode: Syntax {
       switch self {
       case .token(let node): return node._syntaxNode
       case .availabilityVersionRestriction(let node): return node._syntaxNode
       case .availabilityLabeledArgument(let node): return node._syntaxNode
-      case .tokenList(let node): return node._syntaxNode
       }
     }
     init(_ data: SyntaxData) { self.init(Syntax(data))! }
@@ -26753,9 +26751,6 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     public init(_ node: AvailabilityLabeledArgumentSyntax) {
       self = .availabilityLabeledArgument(node)
     }
-    public init(_ node: TokenListSyntax) {
-      self = .tokenList(node)
-    }
     public init?<S: SyntaxProtocol>(_ node: S) {
       if let node = node.as(TokenSyntax.self) {
         self = .token(node)
@@ -26769,10 +26764,6 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
         self = .availabilityLabeledArgument(node)
         return
       }
-      if let node = node.as(TokenListSyntax.self) {
-        self = .tokenList(node)
-        return
-      }
       return nil
     }
 
@@ -26781,7 +26772,6 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
         .node(TokenSyntax.self),
         .node(AvailabilityVersionRestrictionSyntax.self),
         .node(AvailabilityLabeledArgumentSyntax.self),
-        .node(TokenListSyntax.self),
       ])
     }
   }

gyb_syntax_support/AvailabilityNodes.py

@@ -27,7 +27,6 @@
                              kind='AvailabilityVersionRestriction'),
                        Child('AvailabilityLabeledArgument',
                              kind='AvailabilityLabeledArgument'),
-                       Child('TokenList', kind='TokenList'),
                    ]),
              Child('TrailingComma', kind='CommaToken', is_optional=True,
                    description='''