Introduce genericArgumentType and parse integer generics

Author: Azoy

CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift

@@ -307,7 +307,7 @@ public let GENERIC_NODES: [Node] = [
       Child(
         name: "leftType",
         deprecatedName: "leftTypeIdentifier",
-        kind: .node(kind: .type),
+        kind: .node(kind: .genericArgumentType),
         nameForDiagnostics: "left-hand type"
       ),
       Child(
@@ -318,7 +318,7 @@ public let GENERIC_NODES: [Node] = [
       Child(
         name: "rightType",
         deprecatedName: "rightTypeIdentifier",
-        kind: .node(kind: .type),
+        kind: .node(kind: .genericArgumentType),
         nameForDiagnostics: "right-hand type"
       ),
     ]

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -142,6 +142,7 @@ 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,7 @@ public let TYPE_NODES: [Node] = [
       Child(
         name: "argument",
         deprecatedName: "argumentType",
-        kind: .node(kind: .type)
+        kind: .node(kind: .genericArgumentType)
       ),
       Child(
         name: "trailingComma",
@@ -604,4 +604,25 @@ 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)
+          )
+        ])
+      )
+    ]
+  )
 ]

Sources/SwiftParser/Declarations.swift

@@ -532,16 +532,17 @@ extension Parser {
       var keepGoing: RawTokenSyntax? = nil
       var loopProgress = LoopProgressCondition()
       repeat {
-        let firstType = self.parseType()
-        guard !firstType.is(RawMissingTypeSyntax.self) else {
+        let firstArgument = self.parseGenericArgumentType()
+
+        guard !firstArgument.value.raw.is(RawMissingTypeSyntax.self) else {
           keepGoing = self.consume(if: .comma)
           elements.append(
             RawGenericRequirementSyntax(
               requirement: .sameTypeRequirement(
                 RawSameTypeRequirementSyntax(
-                  leftType: RawMissingTypeSyntax(arena: self.arena),
+                  leftType: firstArgument,
                   equal: missingToken(.binaryOperator, text: "=="),
-                  rightType: RawMissingTypeSyntax(arena: self.arena),
+                  rightType: firstArgument,
                   arena: self.arena
                 )
               ),
@@ -552,137 +553,164 @@ extension Parser {
           continue
         }
 
-        enum ExpectedTokenKind: TokenSpecSet {
-          case colon
-          case binaryOperator
-          case postfixOperator
-          case prefixOperator
-
-          init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-            switch (lexeme.rawTokenKind, lexeme.tokenText) {
-            case (.colon, _): self = .colon
-            case (.binaryOperator, "=="): self = .binaryOperator
-            case (.postfixOperator, "=="): self = .postfixOperator
-            case (.prefixOperator, "=="): self = .prefixOperator
-            default: return nil
+        let requirement: RawGenericRequirementSyntax.Requirement
+
+        switch RawGenericArgumentTypeSyntax.Value(firstArgument.value.raw)! {
+        // 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.
+        case .expr:
+          let (unexpectedBeforeEqual, equal) = self.expect(
+            anyIn: SameTypeRequirementSyntax.EqualOptions.self,
+            default: .binaryOperator
+          )
+          let secondArgument = self.parseGenericArgumentType()
+          requirement = .sameTypeRequirement(
+            RawSameTypeRequirementSyntax(
+              leftType: firstArgument,
+              unexpectedBeforeEqual,
+              equal: equal,
+              rightType: secondArgument,
+              arena: self.arena
+            )
+          )
+
+        // Otherwise, this can be a conformance, same type, or layout constraint.
+        case .type(let firstType):
+          enum ExpectedTokenKind: TokenSpecSet {
+            case colon
+            case binaryOperator
+            case postfixOperator
+            case prefixOperator
+
+            init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+              switch (lexeme.rawTokenKind, lexeme.tokenText) {
+              case (.colon, _): self = .colon
+              case (.binaryOperator, "=="): self = .binaryOperator
+              case (.postfixOperator, "=="): self = .postfixOperator
+              case (.prefixOperator, "=="): self = .prefixOperator
+              default: return nil
+              }
             }
-          }
 
-          var spec: TokenSpec {
-            switch self {
-            case .colon: return .colon
-            case .binaryOperator: return .binaryOperator
-            case .postfixOperator: return .postfixOperator
-            case .prefixOperator: return .prefixOperator
+            var spec: TokenSpec {
+              switch self {
+              case .colon: return .colon
+              case .binaryOperator: return .binaryOperator
+              case .postfixOperator: return .postfixOperator
+              case .prefixOperator: return .prefixOperator
+              }
             }
           }
-        }
 
-        let requirement: RawGenericRequirementSyntax.Requirement
-        switch self.at(anyIn: ExpectedTokenKind.self) {
-        case (.colon, let handle)?:
-          let colon = self.eat(handle)
-          // A conformance-requirement.
-          if let (layoutSpecifier, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutSpecifierOptions.self) {
-            // Parse a layout constraint.
-            let specifier = self.eat(handle)
-
-            let unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax?
-            let leftParen: RawTokenSyntax?
-            let size: RawTokenSyntax?
-            let comma: RawTokenSyntax?
-            let alignment: RawTokenSyntax?
-            let unexpectedBeforeRightParen: RawUnexpectedNodesSyntax?
-            let rightParen: RawTokenSyntax?
-
-            var hasArguments: Bool {
-              switch layoutSpecifier {
-              case ._Trivial,
-                ._TrivialAtMost,
-                ._TrivialStride:
-                return true
-
-              case ._UnknownLayout,
-                ._RefCountedObject,
-                ._NativeRefCountedObject,
-                ._Class,
-                ._NativeClass,
-                ._BridgeObject:
-                return false
+          switch self.at(anyIn: ExpectedTokenKind.self) {
+          case (.colon, let handle)?:
+            let colon = self.eat(handle)
+            // A conformance-requirement.
+            if let (layoutSpecifier, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutSpecifierOptions.self) {
+              // Parse a layout constraint.
+              let specifier = self.eat(handle)
+
+              let unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax?
+              let leftParen: RawTokenSyntax?
+              let size: RawTokenSyntax?
+              let comma: RawTokenSyntax?
+              let alignment: RawTokenSyntax?
+              let unexpectedBeforeRightParen: RawUnexpectedNodesSyntax?
+              let rightParen: RawTokenSyntax?
+
+              var hasArguments: Bool {
+                switch layoutSpecifier {
+                case ._Trivial,
+                  ._TrivialAtMost,
+                  ._TrivialStride:
+                  return true
+
+                case ._UnknownLayout,
+                  ._RefCountedObject,
+                  ._NativeRefCountedObject,
+                  ._Class,
+                  ._NativeClass,
+                  ._BridgeObject:
+                  return false
+                }
               }
-            }
 
-            // Unlike the other layout constraints, _Trivial's argument list
-            // is optional.
-            if hasArguments && (layoutSpecifier != ._Trivial || self.at(.leftParen)) {
-              (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-              size = self.expectWithoutRecovery(.integerLiteral)
-              comma = self.consume(if: .comma)
-              if comma != nil {
-                alignment = self.expectWithoutRecovery(.integerLiteral)
+              // Unlike the other layout constraints, _Trivial's argument list
+              // is optional.
+              if hasArguments && (layoutSpecifier != ._Trivial || self.at(.leftParen)) {
+                (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
+                size = self.expectWithoutRecovery(.integerLiteral)
+                comma = self.consume(if: .comma)
+                if comma != nil {
+                  alignment = self.expectWithoutRecovery(.integerLiteral)
+                } else {
+                  alignment = nil
+                }
+                (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
               } else {
+                unexpectedBeforeLeftParen = nil
+                leftParen = nil
+                size = nil
+                comma = nil
                 alignment = nil
+                unexpectedBeforeRightParen = nil
+                rightParen = nil
               }
-              (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
+
+              requirement = .layoutRequirement(
+                RawLayoutRequirementSyntax(
+                  type: firstType,
+                  colon: colon,
+                  layoutSpecifier: specifier,
+                  unexpectedBeforeLeftParen,
+                  leftParen: leftParen,
+                  size: size,
+                  comma: comma,
+                  alignment: alignment,
+                  unexpectedBeforeRightParen,
+                  rightParen: rightParen,
+                  arena: self.arena
+                )
+              )
             } else {
-              unexpectedBeforeLeftParen = nil
-              leftParen = nil
-              size = nil
-              comma = nil
-              alignment = nil
-              unexpectedBeforeRightParen = nil
-              rightParen = nil
+              // Parse the protocol or composition.
+              let secondType = self.parseType()
+              requirement = .conformanceRequirement(
+                RawConformanceRequirementSyntax(
+                  leftType: firstType,
+                  colon: colon,
+                  rightType: secondType,
+                  arena: self.arena
+                )
+              )
             }
-
-            requirement = .layoutRequirement(
-              RawLayoutRequirementSyntax(
-                type: firstType,
-                colon: colon,
-                layoutSpecifier: specifier,
-                unexpectedBeforeLeftParen,
-                leftParen: leftParen,
-                size: size,
-                comma: comma,
-                alignment: alignment,
-                unexpectedBeforeRightParen,
-                rightParen: rightParen,
+          case (.binaryOperator, let handle)?,
+            (.postfixOperator, let handle)?,
+            (.prefixOperator, let handle)?:
+            let equal = self.eat(handle)
+            let secondArgument = self.parseGenericArgumentType()
+            requirement = .sameTypeRequirement(
+              RawSameTypeRequirementSyntax(
+                leftType: firstArgument,
+                equal: equal,
+                rightType: secondArgument,
                 arena: self.arena
               )
             )
-          } else {
-            // Parse the protocol or composition.
-            let secondType = self.parseType()
-            requirement = .conformanceRequirement(
-              RawConformanceRequirementSyntax(
-                leftType: firstType,
-                colon: colon,
-                rightType: secondType,
+          case nil:
+            requirement = .sameTypeRequirement(
+              RawSameTypeRequirementSyntax(
+                leftType: firstArgument,
+                equal: RawTokenSyntax(missing: .binaryOperator, text: "==", arena: self.arena),
+                rightType: RawGenericArgumentTypeSyntax(
+                  value: .type(RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))),
+                  arena: self.arena
+                ),
                 arena: self.arena
               )
             )
           }
-        case (.binaryOperator, let handle)?,
-          (.postfixOperator, let handle)?,
-          (.prefixOperator, let handle)?:
-          let equal = self.eat(handle)
-          let secondType = self.parseType()
-          requirement = .sameTypeRequirement(
-            RawSameTypeRequirementSyntax(
-              leftType: firstType,
-              equal: equal,
-              rightType: secondType,
-              arena: self.arena
-            )
-          )
-        case nil:
-          requirement = .sameTypeRequirement(
-            RawSameTypeRequirementSyntax(
-              leftType: firstType,
-              equal: RawTokenSyntax(missing: .binaryOperator, text: "==", arena: self.arena),
-              rightType: RawMissingTypeSyntax(arena: self.arena),
-              arena: self.arena
-            )
-          )
         }
 
         keepGoing = self.consume(if: .comma)