Address ASTGen feedback

Author: Azoy

lib/ASTGen/Sources/ASTGen/Generics.swift

@@ -13,6 +13,7 @@
 import ASTBridging
 
 @_spi(ExperimentalLanguageFeatures)
+@_spi(RawSyntax)
 import SwiftSyntax
 
 extension ASTGenVisitor {
@@ -95,30 +96,8 @@ extension ASTGenVisitor {
     case .type(let type):
       return self.generate(type: type)
 
-    // The only expressions same type left types support right now are
-    // integer literals, '123', and prefix operators for negative integer
-    // literals, '-123'.
     case .expr(let expr):
-      switch expr.as(ExprSyntaxEnum.self) {
-      case .integerLiteralExpr(let node):
-        return self.generate(integerType: node)
-
-      case .prefixOperatorExpr(let node):
-        let op = node.operator
-
-        guard op.text == "-" else {
-          fatalError("Unknown prefix operator for same type left type")
-        }
-
-        guard case .integerLiteralExpr(let node) = node.expression.as(ExprSyntaxEnum.self) else {
-          fatalError("Unknown expression kind for same type left type")
-        }
-
-        return self.generate(integerType: node, minusLoc: self.generateSourceLoc(op))
-
-      default:
-        fatalError("Unknown expression kind for same type left type")
-      }
+      return self.generateIntegerType(expr: expr).asTypeRepr
     }
   }
 
@@ -127,30 +106,8 @@ extension ASTGenVisitor {
     case .type(let type):
       return self.generate(type: type)
 
-    // The only expressions same type right types support right now are
-    // integer literals, '123', and prefix operators for negative integer
-    // literals, '-123'.
     case .expr(let expr):
-      switch expr.as(ExprSyntaxEnum.self) {
-      case .integerLiteralExpr(let node):
-        return self.generate(integerType: node)
-
-      case .prefixOperatorExpr(let node):
-        let op = node.operator
-
-        guard op.text == "-" else {
-          fatalError("Unknown prefix operator for same type right type")
-        }
-
-        guard case .integerLiteralExpr(let node) = node.expression.as(ExprSyntaxEnum.self) else {
-          fatalError("Unknown expression kind for same type right type")
-        }
-
-        return self.generate(integerType: node, minusLoc: self.generateSourceLoc(op))
-
-      default:
-        fatalError("Unknown expression kind for same type right type")
-      }
+      return self.generateIntegerType(expr: expr).asTypeRepr
     }
   }
 
@@ -159,47 +116,45 @@ extension ASTGenVisitor {
     case .type(let type):
       return self.generate(type: type)
 
-    // The only expressions generic argument types support right now are
-    // integer literals, '123', and prefix operators for negative integer
-    // literals, '-123'.
     case .expr(let expr):
-      switch expr.as(ExprSyntaxEnum.self) {
-      case .integerLiteralExpr(let node):
-        return self.generate(integerType: node)
+      return self.generateIntegerType(expr: expr).asTypeRepr
+    }
+  }
 
-      case .prefixOperatorExpr(let node):
-        let op = node.operator
+  func generateIntegerType(expr node: ExprSyntax) -> BridgedIntegerTypeRepr {
+    var minusLoc = BridgedSourceLoc()
+    let literalExpr: IntegerLiteralExprSyntax
 
-        guard op.text == "-" else {
-          fatalError("Unknown prefix operator for generic argument type")
-        }
+    // The only expressions generic argument types support right now are
+    // integer literals, '123', and prefix operators for negative integer
+    // literals, '-123'.
+    switch node.as(ExprSyntaxEnum.self) {
+    case .integerLiteralExpr(let node):
+      literalExpr = node
 
-        guard case .integerLiteralExpr(let node) = node.expression.as(ExprSyntaxEnum.self) else {
-          fatalError("Unknown expression kind for generic argument type")
-        }
+    case .prefixOperatorExpr(let node):
+      let op = node.operator
 
-        return self.generate(integerType: node, minusLoc: self.generateSourceLoc(op))
+      guard op.text == "-" else {
+        fatalError("Unknown prefix operator for generic argument type")
+      }
 
-      default:
+      guard let node = node.expression.as(IntegerLiteralExprSyntax.self) else {
         fatalError("Unknown expression kind for generic argument type")
       }
-    }
-  }
 
-  func generate(
-    integerType node: IntegerLiteralExprSyntax,
-    minusLoc: BridgedSourceLoc = BridgedSourceLoc()
-  ) -> BridgedTypeRepr {
-    var desc = node.trimmedDescription
-    let str = desc.withBridgedString {
-      self.ctx.allocateCopy(string: $0)
+      minusLoc = self.generateSourceLoc(op)
+      literalExpr = node
+
+    default:
+      fatalError("Unknown expression kind for generic argument type")
     }
 
-    return BridgedIntegerTypeRepr.createParsed(
+    return .createParsed(
       self.ctx,
-      string: str,
-      loc: self.generateSourceLoc(node),
+      string: self.copyAndStripUnderscores(text: literalExpr.literal.rawText),
+      loc: self.generateSourceLoc(literalExpr),
       minusLoc: minusLoc
-    ).asTypeRepr
+    )
   }
 }

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -75,6 +75,7 @@ extension Parser.ExperimentalFeatures {
     mapFeature(.NonescapableTypes, to: .nonescapableTypes)
     mapFeature(.TrailingComma, to: .trailingComma)
     mapFeature(.CoroutineAccessors, to: .coroutineAccessors)
+    mapFeature(.ValueGenerics, to: .valueGenerics)
   }
 }