Implement syntax and parsing for value generics

Author: Azoy

CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift

@@ -93,10 +93,12 @@ public let GENERIC_NODES: [Node] = [
         kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true)
       ),
       Child(
-        name: "eachKeyword",
-        deprecatedName: "each",
-        kind: .token(choices: [.keyword(.each)]),
-        nameForDiagnostics: "parameter pack specifier",
+        name: "specifier",
+        kind: .token(choices: [
+          .keyword(.each),
+          .keyword(.let)
+        ]),
+        nameForDiagnostics: "specifier",
         isOptional: true
       ),
       Child(

Sources/SwiftParser/Declarations.swift

@@ -431,11 +431,18 @@ extension Parser {
       repeat {
         let attributes = self.parseAttributeList()
 
-        // Parse the 'each' keyword for a type parameter pack 'each T'.
-        var each = self.consume(if: .keyword(.each))
+        var specifier: Token? = nil
+
+        // Parse the 'each' keyword for a type parameter pack 'each T' or a
+        // 'let' keyword for a value parameter 'let N: Int'.
+        if let each = self.consume(if: .keyword(.each)) {
+          specifier = each
+        } else if let `let` = self.consume(if: .keyword(.let)) {
+          specifier = `let`
+        }
 
-        let (unexpectedBetweenEachAndName, name) = self.expectIdentifier(allowSelfOrCapitalSelfAsIdentifier: true)
-        if attributes.isEmpty && each == nil && unexpectedBetweenEachAndName == nil && name.isMissing
+        let (unexpectedBetweenSpecifierAndName, name) = self.expectIdentifier(allowSelfOrCapitalSelfAsIdentifier: true)
+        if attributes.isEmpty && specifier == nil && unexpectedBetweenSpecifierAndName == nil && name.isMissing
           && elements.isEmpty && !self.at(prefix: ">")
         {
           break
@@ -445,8 +452,8 @@ extension Parser {
         let unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax?
         if let ellipsis = self.consume(ifPrefix: "...", as: .ellipsis) {
           unexpectedBetweenNameAndColon = RawUnexpectedNodesSyntax([ellipsis], arena: self.arena)
-          if each == nil {
-            each = missingToken(.each)
+          if specifier == nil {
+            specifier = missingToken(.each)
           }
         } else {
           unexpectedBetweenNameAndColon = nil
@@ -481,8 +488,8 @@ extension Parser {
         elements.append(
           RawGenericParameterSyntax(
             attributes: attributes,
-            eachKeyword: each,
-            unexpectedBetweenEachAndName,
+            specifier: specifier,
+            unexpectedBetweenSpecifierAndName,
             name: name,
             unexpectedBetweenNameAndColon,
             colon: colon,

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -1852,6 +1852,58 @@ extension FunctionParameterSyntax {
   }
 }
 
+extension GenericParameterSyntax {
+  @_spi(Diagnostics)
+  public enum SpecifierOptions: TokenSpecSet {
+    case each
+    case `let`
+    
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.each):
+        self = .each
+      case TokenSpec(.let):
+        self = .let
+      default:
+        return nil
+      }
+    }
+    
+    public init?(token: TokenSyntax) {
+      switch token {
+      case TokenSpec(.each):
+        self = .each
+      case TokenSpec(.let):
+        self = .let
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .each:
+        return .keyword(.each)
+      case .let:
+        return .keyword(.let)
+      }
+    }
+    
+    /// Returns a token that satisfies the `TokenSpec` of this case.
+    ///
+    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
+    @_spi(Diagnostics)
+    public var tokenSyntax: TokenSyntax {
+      switch self {
+      case .each:
+        return .keyword(.each)
+      case .let:
+        return .keyword(.let)
+      }
+    }
+  }
+}
+
 extension IdentifierPatternSyntax {
   @_spi(Diagnostics)
   public enum IdentifierOptions: TokenSpecSet {

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1022,15 +1022,16 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       return .skipChildren
     }
     // Emit a custom diagnostic for an unexpected '...' after the type name.
-    if node.eachKeyword?.isPresent ?? false {
+    if node.specifier?.isPresent ?? false {
       removeToken(
         node.unexpectedBetweenNameAndColon,
         where: { $0.tokenKind == .ellipsis },
         message: { _ in .typeParameterPackEllipsis }
       )
     } else if let unexpected = node.unexpectedBetweenNameAndColon,
       let unexpectedEllipsis = unexpected.onlyPresentToken(where: { $0.tokenKind == .ellipsis }),
-      let each = node.eachKeyword
+      let specifier = node.specifier,
+      specifier.tokenKind == .keyword(.each)
     {
       addDiagnostic(
         unexpected,
@@ -1040,11 +1041,11 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
             message: ReplaceTokensFixIt(replaceTokens: [unexpectedEllipsis], replacements: [.keyword(.each)]),
             changes: [
               .makeMissing(unexpected),
-              .makePresent(each, trailingTrivia: .space),
+              .makePresent(specifier, trailingTrivia: .space)
             ]
           )
         ],
-        handledNodes: [unexpected.id, each.id]
+        handledNodes: [unexpected.id, specifier.id]
       )
     }
     if let inheritedTypeName = node.inheritedType?.as(IdentifierTypeSyntax.self)?.name {

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -168,8 +168,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "type"
   case \FunctionParameterSyntax.defaultValue:
     return "default value"
-  case \GenericParameterSyntax.eachKeyword:
-    return "parameter pack specifier"
+  case \GenericParameterSyntax.specifier:
+    return "specifier"
   case \GenericParameterSyntax.name:
     return "name"
   case \GenericParameterSyntax.inheritedType:

Sources/SwiftRefactor/OpaqueParameterToGeneric.swift

@@ -60,7 +60,7 @@ fileprivate class SomeParameterRewriter: SyntaxRewriter {
 
     let genericParam = GenericParameterSyntax(
       attributes: [],
-      eachKeyword: nil,
+      specifier: nil,
       name: paramNameSyntax,
       colon: colon,
       inheritedType: inheritedType,

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1551,12 +1551,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBeforeAttributes"
   case \GenericParameterSyntax.attributes:
     return "attributes"
-  case \GenericParameterSyntax.unexpectedBetweenAttributesAndEachKeyword:
-    return "unexpectedBetweenAttributesAndEachKeyword"
-  case \GenericParameterSyntax.eachKeyword:
-    return "eachKeyword"
-  case \GenericParameterSyntax.unexpectedBetweenEachKeywordAndName:
-    return "unexpectedBetweenEachKeywordAndName"
+  case \GenericParameterSyntax.unexpectedBetweenAttributesAndSpecifier:
+    return "unexpectedBetweenAttributesAndSpecifier"
+  case \GenericParameterSyntax.specifier:
+    return "specifier"
+  case \GenericParameterSyntax.unexpectedBetweenSpecifierAndName:
+    return "unexpectedBetweenSpecifierAndName"
   case \GenericParameterSyntax.name:
     return "name"
   case \GenericParameterSyntax.unexpectedBetweenNameAndColon:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift

@@ -390,9 +390,9 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol {
   public init(
       _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, 
       attributes: RawAttributeListSyntax, 
-      _ unexpectedBetweenAttributesAndEachKeyword: RawUnexpectedNodesSyntax? = nil, 
-      eachKeyword: RawTokenSyntax?, 
-      _ unexpectedBetweenEachKeywordAndName: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenAttributesAndSpecifier: RawUnexpectedNodesSyntax? = nil, 
+      specifier: RawTokenSyntax?, 
+      _ unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? = nil, 
       name: RawTokenSyntax, 
       _ unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax? = nil, 
       colon: RawTokenSyntax?, 
@@ -408,9 +408,9 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol {
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
-      layout[2] = unexpectedBetweenAttributesAndEachKeyword?.raw
-      layout[3] = eachKeyword?.raw
-      layout[4] = unexpectedBetweenEachKeywordAndName?.raw
+      layout[2] = unexpectedBetweenAttributesAndSpecifier?.raw
+      layout[3] = specifier?.raw
+      layout[4] = unexpectedBetweenSpecifierAndName?.raw
       layout[5] = name.raw
       layout[6] = unexpectedBetweenNameAndColon?.raw
       layout[7] = colon?.raw
@@ -431,15 +431,15 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol {
     layoutView.children[1].map(RawAttributeListSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenAttributesAndEachKeyword: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenAttributesAndSpecifier: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var eachKeyword: RawTokenSyntax? {
+  public var specifier: RawTokenSyntax? {
     layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenEachKeywordAndName: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -1357,7 +1357,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("each")]))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("each"), .keyword("let")]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift

@@ -532,7 +532,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea
 /// ### Children
 /// 
 ///  - `attributes`: ``AttributeListSyntax``
-///  - `eachKeyword`: `each`?
+///  - `specifier`: (`each` | `let`)?
 ///  - `name`: `<identifier>`
 ///  - `colon`: `:`?
 ///  - `inheritedType`: ``TypeSyntax``?
@@ -558,9 +558,9 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
       leadingTrivia: Trivia? = nil,
       _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
       attributes: AttributeListSyntax = [],
-      _ unexpectedBetweenAttributesAndEachKeyword: UnexpectedNodesSyntax? = nil,
-      eachKeyword: TokenSyntax? = nil,
-      _ unexpectedBetweenEachKeywordAndName: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenAttributesAndSpecifier: UnexpectedNodesSyntax? = nil,
+      specifier: TokenSyntax? = nil,
+      _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil,
       name: TokenSyntax,
       _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil,
       colon: TokenSyntax? = nil,
@@ -576,9 +576,9 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
     self = withExtendedLifetime((SyntaxArena(), (
             unexpectedBeforeAttributes, 
             attributes, 
-            unexpectedBetweenAttributesAndEachKeyword, 
-            eachKeyword, 
-            unexpectedBetweenEachKeywordAndName, 
+            unexpectedBetweenAttributesAndSpecifier, 
+            specifier, 
+            unexpectedBetweenSpecifierAndName, 
             name, 
             unexpectedBetweenNameAndColon, 
             colon, 
@@ -591,9 +591,9 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
       let layout: [RawSyntax?] = [
           unexpectedBeforeAttributes?.raw, 
           attributes.raw, 
-          unexpectedBetweenAttributesAndEachKeyword?.raw, 
-          eachKeyword?.raw, 
-          unexpectedBetweenEachKeywordAndName?.raw, 
+          unexpectedBetweenAttributesAndSpecifier?.raw, 
+          specifier?.raw, 
+          unexpectedBetweenSpecifierAndName?.raw, 
           name.raw, 
           unexpectedBetweenNameAndColon?.raw, 
           colon?.raw, 
@@ -659,7 +659,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
       .cast(GenericParameterSyntax.self)
   }
 
-  public var unexpectedBetweenAttributesAndEachKeyword: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenAttributesAndSpecifier: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -670,8 +670,10 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
 
   /// ### Tokens
   /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be `each`.
-  public var eachKeyword: TokenSyntax? {
+  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
+  ///  - `each`
+  ///  - `let`
+  public var specifier: TokenSyntax? {
     get {
       return Syntax(self).child(at: 3)?.cast(TokenSyntax.self)
     }
@@ -680,7 +682,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
     }
   }
 
-  public var unexpectedBetweenEachKeywordAndName: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -773,9 +775,9 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta
   public static let structure: SyntaxNodeStructure = .layout([
         \Self.unexpectedBeforeAttributes, 
         \Self.attributes, 
-        \Self.unexpectedBetweenAttributesAndEachKeyword, 
-        \Self.eachKeyword, 
-        \Self.unexpectedBetweenEachKeywordAndName, 
+        \Self.unexpectedBetweenAttributesAndSpecifier, 
+        \Self.specifier, 
+        \Self.unexpectedBetweenSpecifierAndName, 
         \Self.name, 
         \Self.unexpectedBetweenNameAndColon, 
         \Self.colon,