Merge pull request #77149 from Azoy/swift-syntax-integer-types

[ASTGen/Parse] Implement ASTGen changes for integer generics from Swift Syntax and restrict parsing integer types in certain contexts

Author: ahoppen

include/swift/AST/ASTBridging.h

@@ -1938,6 +1938,12 @@ BridgedVarargTypeRepr_createParsed(BridgedASTContext cContext,
                                    BridgedTypeRepr base,
                                    BridgedSourceLoc cEllipsisLoc);
 
+SWIFT_NAME(
+    "BridgedIntegerTypeRepr.createParsed(_:string:loc:minusLoc:)")
+BridgedIntegerTypeRepr BridgedIntegerTypeRepr_createParsed(
+    BridgedASTContext cContext, BridgedStringRef cString, BridgedSourceLoc cLoc,
+    BridgedSourceLoc cMinusLoc);
+
 SWIFT_NAME("BridgedTypeRepr.dump(self:)")
 void BridgedTypeRepr_dump(BridgedTypeRepr type);
 

include/swift/Parse/Parser.h

@@ -1411,6 +1411,11 @@ class Parser {
   ParserResult<TypeRepr> parseTypeSimple(
       Diag<> MessageID, ParseTypeReason reason);
 
+  ParserResult<TypeRepr> parseTypeOrValue();
+  ParserResult<TypeRepr> parseTypeOrValue(Diag<> MessageID,
+                          ParseTypeReason reason = ParseTypeReason::Unspecified,
+                          bool fromASTGen = false);
+
   /// Parse layout constraint.
   LayoutConstraint parseLayoutConstraint(Identifier LayoutConstraintID);
 

lib/AST/Bridging/TypeReprBridging.cpp

@@ -298,3 +298,13 @@ BridgedExistentialTypeRepr_createParsed(BridgedASTContext cContext,
   return new (context)
       ExistentialTypeRepr(cAnyLoc.unbridged(), baseTy.unbridged());
 }
+
+BridgedIntegerTypeRepr
+BridgedIntegerTypeRepr_createParsed(BridgedASTContext cContext,
+                                    BridgedStringRef cString,
+                                    BridgedSourceLoc cLoc,
+                                    BridgedSourceLoc cMinusLoc) {
+  ASTContext &context = cContext.unbridged();
+  return new (context) IntegerTypeRepr(cString.unbridged(), cLoc.unbridged(),
+                                       cMinusLoc.unbridged());
+}

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -659,7 +659,7 @@ extension ASTGenVisitor {
     if let generics = node.genericArgumentClause {
       leftAngleLoc = self.generateSourceLoc(generics.leftAngle)
       genericArgs = generics.arguments.map {
-        self.generate(type: $0.argument)
+        self.generate(genericArgument: $0.argument)
       }
       rightAngleLoc = self.generateSourceLoc(generics.rightAngle)
     } else {
@@ -760,7 +760,7 @@ extension ASTGenVisitor {
     let generics = node.genericArgumentClause
     let lAngleLoc = self.generateSourceLoc(generics.leftAngle)
     let genericArguments = generics.arguments.lazy.map {
-      self.generate(type: $0.argument)
+      self.generate(genericArgument: $0.argument)
     }
     let rAngleLoc = self.generateSourceLoc(generics.rightAngle)
     return .createParsed(

lib/ASTGen/Sources/ASTGen/Generics.swift

@@ -11,6 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 import ASTBridging
+
+@_spi(ExperimentalLanguageFeatures)
+@_spi(RawSyntax)
 import SwiftSyntax
 
 extension ASTGenVisitor {
@@ -72,8 +75,8 @@ extension ASTGenVisitor {
         return BridgedRequirementRepr(
           SeparatorLoc: self.generateSourceLoc(sameType.equal),
           Kind: .sameType,
-          FirstType: self.generate(type: sameType.leftType),
-          SecondType: self.generate(type: sameType.rightType)
+          FirstType: self.generate(sameTypeLeftType: sameType.leftType),
+          SecondType: self.generate(sameTypeRightType: sameType.rightType)
         )
       case .layoutRequirement(_):
         // FIXME: Implement layout requirement translation.
@@ -87,4 +90,71 @@ extension ASTGenVisitor {
       requirements: requirements.bridgedArray(in: self)
     )
   }
+
+  func generate(sameTypeLeftType node: SameTypeRequirementSyntax.LeftType) -> BridgedTypeRepr {
+    switch node {
+    case .type(let type):
+      return self.generate(type: type)
+
+    case .expr(let expr):
+      return self.generateIntegerType(expr: expr).asTypeRepr
+    }
+  }
+
+  func generate(sameTypeRightType node: SameTypeRequirementSyntax.RightType) -> BridgedTypeRepr {
+    switch node {
+    case .type(let type):
+      return self.generate(type: type)
+
+    case .expr(let expr):
+      return self.generateIntegerType(expr: expr).asTypeRepr
+    }
+  }
+
+  func generate(genericArgument node: GenericArgumentSyntax.Argument) -> BridgedTypeRepr {
+    switch node {
+    case .type(let type):
+      return self.generate(type: type)
+
+    case .expr(let expr):
+      return self.generateIntegerType(expr: expr).asTypeRepr
+    }
+  }
+
+  func generateIntegerType(expr node: ExprSyntax) -> BridgedIntegerTypeRepr {
+    var minusLoc = BridgedSourceLoc()
+    let literalExpr: IntegerLiteralExprSyntax
+
+    // 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
+
+    case .prefixOperatorExpr(let node):
+      let op = node.operator
+
+      guard op.text == "-" else {
+        fatalError("Unknown prefix operator for generic argument type")
+      }
+
+      guard let node = node.expression.as(IntegerLiteralExprSyntax.self) else {
+        fatalError("Unknown expression kind for generic argument type")
+      }
+
+      minusLoc = self.generateSourceLoc(op)
+      literalExpr = node
+
+    default:
+      fatalError("Unknown expression kind for generic argument type")
+    }
+
+    return .createParsed(
+      self.ctx,
+      string: self.copyAndStripUnderscores(text: literalExpr.literal.rawText),
+      loc: self.generateSourceLoc(literalExpr),
+      minusLoc: minusLoc
+    )
+  }
 }

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)
   }
 }
 

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -120,7 +120,7 @@ extension ASTGenVisitor {
     }
 
     let genericArguments = generics.arguments.lazy.map {
-      self.generate(type: $0.argument)
+      self.generate(genericArgument: $0.argument)
     }
 
     return BridgedUnqualifiedIdentTypeRepr.createParsed(
@@ -140,7 +140,7 @@ extension ASTGenVisitor {
     let angleRange: BridgedSourceRange
     if let generics = node.genericArgumentClause {
       genericArguments = generics.arguments.lazy.map {
-        self.generate(type: $0.argument)
+        self.generate(genericArgument: $0.argument)
       }.bridgedArray(in: self)
 
       angleRange = self.generateSourceRange(start: generics.leftAngle, end: generics.rightAngle)

lib/Macros/Sources/SwiftMacros/DistributedResolvableMacro.swift

@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@_spi(ExperimentalLanguageFeatures)
 import SwiftSyntax
 import SwiftSyntaxMacros
 import SwiftDiagnostics
@@ -141,10 +142,25 @@ extension DistributedResolvableMacro {
         specificActorSystemRequirement = conformanceReq.rightType.trimmed
         isGenericStub = true
 
-      case .sameTypeRequirement(let sameTypeReq)
-           where sameTypeReq.leftType.isActorSystem:
-        specificActorSystemRequirement = sameTypeReq.rightType.trimmed
-        isGenericStub = false
+      case .sameTypeRequirement(let sameTypeReq):
+        switch sameTypeReq.leftType {
+        case .type(let type) where type.isActorSystem:
+          switch sameTypeReq.rightType.trimmed {
+          case .type(let rightType):
+            specificActorSystemRequirement = rightType
+            isGenericStub = false
+
+          case .expr:
+            throw DiagnosticsError(
+              syntax: sameTypeReq.rightType,
+              message: "Expression type not supported for distributed actor",
+              id: .invalidGenericArgument
+            )
+          }
+
+        default:
+          continue
+        }
 
       default:
         continue
@@ -265,6 +281,7 @@ struct DistributedResolvableMacroDiagnostic: DiagnosticMessage {
   enum ID: String {
     case invalidApplication = "invalid type"
     case missingInitializer = "missing initializer"
+    case invalidGenericArgument = "invalid generic argument"
   }
 
   var message: String

lib/Macros/Sources/SwiftMacros/OptionSetMacro.swift

@@ -72,7 +72,7 @@ public struct OptionSetMacro {
     of attribute: AttributeSyntax,
     attachedTo decl: Decl,
     in context: Context
-  ) -> (StructDeclSyntax, EnumDeclSyntax, TypeSyntax)? {
+  ) -> (StructDeclSyntax, EnumDeclSyntax, GenericArgumentSyntax.Argument)? {
     // Determine the name of the options enum.
     let optionsEnumName: String
     if case let .argumentList(arguments) = attribute.arguments,

lib/Parse/ParseDecl.cpp

@@ -3963,7 +3963,7 @@ ParserStatus Parser::parseNewDeclAttribute(DeclAttributes &Attributes,
         return makeParserSuccess();
       }
 
-      auto countType = parseType(diag::expected_type);
+      auto countType = parseTypeOrValue(diag::expected_type);
       if (countType.isNull()) {
         return makeParserSuccess();
       }