Use node choices instead of new node type

Author: Azoy

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -19,6 +19,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case nonescapableTypes
   case trailingComma
   case coroutineAccessors
+  case valueGenerics
 
   /// The name of the feature, which is used in the doc comment.
   public var featureName: String {
@@ -35,6 +36,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "trailing comma"
     case .coroutineAccessors:
       return "CoroutineAccessors"
+    case .valueGenerics:
+      return "ValueGenerics"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift

@@ -307,8 +307,20 @@ public let GENERIC_NODES: [Node] = [
       Child(
         name: "leftType",
         deprecatedName: "leftTypeIdentifier",
-        kind: .node(kind: .genericArgumentType),
-        nameForDiagnostics: "left-hand type"
+        kind: .nodeChoices(choices: [
+          Child(
+            name: "type",
+            kind: .node(kind: .type)
+          ),
+          Child(
+            name: "expr",
+            kind: .node(kind: .expr),
+            experimentalFeature: .valueGenerics
+          ),
+        ]),
+        nameForDiagnostics: "left-hand type",
+        documentation:
+          "The left hand side type for a same type requirement. This can either be a regular type argument or an expression for value generics."
       ),
       Child(
         name: "equal",
@@ -318,8 +330,20 @@ public let GENERIC_NODES: [Node] = [
       Child(
         name: "rightType",
         deprecatedName: "rightTypeIdentifier",
-        kind: .node(kind: .genericArgumentType),
-        nameForDiagnostics: "right-hand type"
+        kind: .nodeChoices(choices: [
+          Child(
+            name: "type",
+            kind: .node(kind: .type)
+          ),
+          Child(
+            name: "expr",
+            kind: .node(kind: .expr),
+            experimentalFeature: .valueGenerics
+          ),
+        ]),
+        nameForDiagnostics: "right-hand type",
+        documentation:
+          "The right hand side type for a same type requirement. This can either be a regular type argument or an expression for value generics."
       ),
     ]
   ),

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -142,7 +142,6 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case genericArgument
   case genericArgumentClause
   case genericArgumentList
-  case genericArgumentType
   case genericParameter
   case genericParameterClause
   case genericParameterList

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -238,7 +238,19 @@ public let TYPE_NODES: [Node] = [
       Child(
         name: "argument",
         deprecatedName: "argumentType",
-        kind: .node(kind: .genericArgumentType)
+        kind: .nodeChoices(choices: [
+          Child(
+            name: "type",
+            kind: .node(kind: .type)
+          ),
+          Child(
+            name: "expr",
+            kind: .node(kind: .expr),
+            experimentalFeature: .valueGenerics
+          ),
+        ]),
+        documentation:
+          "The argument type for a generic argument. This can either be a regular type argument or an expression for value generics."
       ),
       Child(
         name: "trailingComma",
@@ -604,25 +616,4 @@ public let TYPE_NODES: [Node] = [
     nameForDiagnostics: nil,
     elementChoices: [.simpleTypeSpecifier, .lifetimeTypeSpecifier]
   ),
-
-  Node(
-    kind: .genericArgumentType,
-    base: .type,
-    nameForDiagnostics: "generic argument type",
-    children: [
-      Child(
-        name: "value",
-        kind: .nodeChoices(choices: [
-          Child(
-            name: "type",
-            kind: .node(kind: .type)
-          ),
-          Child(
-            name: "expr",
-            kind: .node(kind: .expr)
-          )
-        ])
-      )
-    ]
-  )
 ]

Release Notes/601.md

@@ -2,6 +2,18 @@
 
 ## New APIs
 
+- `SameTypeRequirementSyntax` has a new `RightType` nested type.
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
+- `SameTypeRequirementSyntax` has a new `LeftType` nested type.
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
+- `GenericArgumentSynax` has a new `Argument` nested type.
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
 - `GenericParameterSyntax` now has a new `specifier` property.
   - Description: With the introduction of value generics, generic parameters can now be optionally preceded by either a `let` or an `each`. The `specifier` property captures the token representing which one was parsed.
   - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2785
@@ -46,6 +58,18 @@
 
 ## API-Incompatible Changes
 
+- `SameTypeRequirementSyntax.rightType` has changed types from `TypeSyntax` to `SameTypeRequirementSyntax.RightType`
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
+- `SameTypeRequirementSyntax.leftType` has changed types from `TypeSyntax` to `SameTypeRequirementSyntax.LeftType`
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
+- `GenericArgumentSyntax.argument` has changed types from `TypeSyntax` to `GenericArgumentSyntax.Argument`
+  - Description: The Swift parser can now parse values as types in certain situations, so the new type reflects the possibility of the argument being either an `ExprSyntax` or a `TypeSyntax`.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2859
+
 - Moved `Radix` and `IntegerLiteralExprSyntax.radix` from `SwiftRefactor` to `SwiftSyntax`.
   - Description: Allows retrieving the radix value from the `literal.text`.
   - Issue: https://github.com/apple/swift-syntax/issues/405

Sources/SwiftParser/Declarations.swift

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6)
-@_spi(RawSyntax) internal import SwiftSyntax
+@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) internal import SwiftSyntax
 #else
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 #endif
 
 extension DeclarationModifier {
@@ -524,6 +524,22 @@ extension Parser {
     return self.at(prefix: ">")
   }
 
+  mutating func parseSameTypeLeftType() -> RawSameTypeRequirementSyntax.LeftType {
+    if let valueType = self.parseValueType() {
+      return .expr(valueType)
+    } else {
+      return .type(self.parseType())
+    }
+  }
+
+  mutating func parseSameTypeRightType() -> RawSameTypeRequirementSyntax.RightType {
+    if let valueType = self.parseValueType() {
+      return .expr(valueType)
+    } else {
+      return .type(self.parseType())
+    }
+  }
+
   mutating func parseGenericWhereClause() -> RawGenericWhereClauseSyntax {
     let (unexpectedBeforeWhereKeyword, whereKeyword) = self.expect(.keyword(.where))
 
@@ -532,17 +548,17 @@ extension Parser {
       var keepGoing: RawTokenSyntax? = nil
       var loopProgress = LoopProgressCondition()
       repeat {
-        let firstArgument = self.parseGenericArgumentType()
+        let firstArgument = self.parseSameTypeLeftType()
 
-        guard !firstArgument.value.raw.is(RawMissingTypeSyntax.self) else {
+        guard !firstArgument.raw.is(RawMissingTypeSyntax.self) else {
           keepGoing = self.consume(if: .comma)
           elements.append(
             RawGenericRequirementSyntax(
               requirement: .sameTypeRequirement(
                 RawSameTypeRequirementSyntax(
                   leftType: firstArgument,
                   equal: missingToken(.binaryOperator, text: "=="),
-                  rightType: firstArgument,
+                  rightType: .type(RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))),
                   arena: self.arena
                 )
               ),
@@ -555,7 +571,7 @@ extension Parser {
 
         let requirement: RawGenericRequirementSyntax.Requirement
 
-        switch RawGenericArgumentTypeSyntax.Value(firstArgument.value.raw)! {
+        switch firstArgument {
         // If the first argument is an expression, then we have to have a same
         // type requirement. We do not allow conformance requirements like
         // '123: Protocol' or layout constraints on expressions.
@@ -564,7 +580,7 @@ extension Parser {
             anyIn: SameTypeRequirementSyntax.EqualOptions.self,
             default: .binaryOperator
           )
-          let secondArgument = self.parseGenericArgumentType()
+          let secondArgument = self.parseSameTypeRightType()
           requirement = .sameTypeRequirement(
             RawSameTypeRequirementSyntax(
               leftType: firstArgument,
@@ -689,7 +705,7 @@ extension Parser {
             (.postfixOperator, let handle)?,
             (.prefixOperator, let handle)?:
             let equal = self.eat(handle)
-            let secondArgument = self.parseGenericArgumentType()
+            let secondArgument = self.parseSameTypeRightType()
             requirement = .sameTypeRequirement(
               RawSameTypeRequirementSyntax(
                 leftType: firstArgument,
@@ -703,10 +719,7 @@ extension Parser {
               RawSameTypeRequirementSyntax(
                 leftType: firstArgument,
                 equal: RawTokenSyntax(missing: .binaryOperator, text: "==", arena: self.arena),
-                rightType: RawGenericArgumentTypeSyntax(
-                  value: .type(RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))),
-                  arena: self.arena
-                ),
+                rightType: .type(RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))),
                 arena: self.arena
               )
             )

Sources/SwiftParser/Types.swift

@@ -418,7 +418,7 @@ extension Parser {
       repeat {
         let argument = self.parseGenericArgumentType()
 
-        if arguments.isEmpty, argument.value.raw.is(RawMissingTypeSyntax.self) {
+        if arguments.isEmpty, argument.raw.is(RawMissingTypeSyntax.self) {
           break
         }
 
@@ -449,17 +449,11 @@ extension Parser {
     )
   }
 
-  mutating func parseGenericArgumentType() -> RawGenericArgumentTypeSyntax {
+  mutating func parseGenericArgumentType() -> RawGenericArgumentSyntax.Argument {
     if let valueType = self.parseValueType() {
-      return RawGenericArgumentTypeSyntax(
-        value: .expr(valueType),
-        arena: self.arena
-      )
+      return .expr(valueType)
     } else {
-      return RawGenericArgumentTypeSyntax(
-        value: .type(self.parseType()),
-        arena: self.arena
-      )
+      return .type(self.parseType())
     }
   }
 }
@@ -710,7 +704,8 @@ extension Parser.Lookahead {
 
       // '-123' for value generics.
       if self.currentToken.tokenText == "-",
-         self.peek(isAt: .integerLiteral) {
+        self.peek(isAt: .integerLiteral)
+      {
         self.consumeAnyToken()
         self.consumeAnyToken()
         return true
@@ -1137,10 +1132,17 @@ extension Parser {
 
 extension Parser {
   mutating func parseValueType() -> RawExprSyntax? {
+    // If the 'ValueGenerics' experimental feature hasn't been added, then don't
+    // attempt to parse values as types.
+    guard self.experimentalFeatures.contains(.valueGenerics) else {
+      return nil
+    }
+
     // Eat any '-' preceding integer literals.
     var minusSign: RawTokenSyntax? = nil
-    if self.currentToken.tokenText == "-",
-       self.peek(isAt: .integerLiteral) {
+    if self.atContextualPunctuator("-"),
+      self.peek(isAt: .integerLiteral)
+    {
       minusSign = self.consumeIfContextualPunctuator("-", remapping: .prefixOperator)
     }
 
@@ -1156,11 +1158,13 @@ extension Parser {
         return RawExprSyntax(integerExpr)
       }
 
-      return RawExprSyntax(RawPrefixOperatorExprSyntax(
-        operator: minusSign,
-        expression: integerExpr,
-        arena: self.arena
-      ))
+      return RawExprSyntax(
+        RawPrefixOperatorExprSyntax(
+          operator: minusSign,
+          expression: integerExpr,
+          arena: self.arena
+        )
+      )
     }
 
     return nil

Sources/SwiftParser/generated/ExperimentalFeatures.swift

@@ -41,4 +41,7 @@ extension Parser.ExperimentalFeatures {
 
   /// Whether to enable the parsing of CoroutineAccessors.
   public static let coroutineAccessors = Self (rawValue: 1 << 5)
+
+  /// Whether to enable the parsing of ValueGenerics.
+  public static let valueGenerics = Self (rawValue: 1 << 6)
 }

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -197,8 +197,6 @@ extension SyntaxKind {
       return "generic argument clause"
     case .genericArgument:
       return "generic argument"
-    case .genericArgumentType:
-      return "generic argument type"
     case .genericParameterClause:
       return "generic parameter clause"
     case .genericParameter:

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

@@ -180,7 +180,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/CompositionTypeSyntax>
 - <doc:SwiftSyntax/DictionaryTypeSyntax>
 - <doc:SwiftSyntax/FunctionTypeSyntax>
-- <doc:SwiftSyntax/GenericArgumentTypeSyntax>
 - <doc:SwiftSyntax/IdentifierTypeSyntax>
 - <doc:SwiftSyntax/ImplicitlyUnwrappedOptionalTypeSyntax>
 - <doc:SwiftSyntax/MemberTypeSyntax>

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1529,12 +1529,6 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \GenericArgumentSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \GenericArgumentTypeSyntax.unexpectedBeforeValue:
-    return "unexpectedBeforeValue"
-  case \GenericArgumentTypeSyntax.value:
-    return "value"
-  case \GenericArgumentTypeSyntax.unexpectedAfterValue:
-    return "unexpectedAfterValue"
   case \GenericParameterClauseSyntax.unexpectedBeforeLeftAngle:
     return "unexpectedBeforeLeftAngle"
   case \GenericParameterClauseSyntax.leftAngle: