swiftlang · ahoppen · May 2, 2023 · May 2, 2023 · May 2, 2023 · May 2, 2023
@@ -48,7 +48,7 @@ public class TokenSpec {
     self.name = name
     self.kind = kind
     self.nameForDiagnostics = nameForDiagnostics
-    if let unprefixedKind = unprefixedKind {
+    if let unprefixedKind {
       self.unprefixedKind = unprefixedKind
     } else {
       self.unprefixedKind = kind

@@ -50,7 +50,11 @@ public extension Child {
   /// function parameter. Otherwise, return `nil`.
   var defaultInitialization: InitializerClauseSyntax? {
     if isOptional || isUnexpectedNodes {
-      return InitializerClauseSyntax(value: NilLiteralExprSyntax())
+      if type.isBaseType && kind.isNodeChoicesEmpty {
+        return InitializerClauseSyntax(value: ExprSyntax("\(type.buildable).none"))
+      } else {
+        return InitializerClauseSyntax(value: NilLiteralExprSyntax())
+      }
     }
     guard let token = token, isToken else {
       return type.defaultValue.map { InitializerClauseSyntax(value: $0) }

@@ -160,7 +160,7 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in an optional depending on whether `isOptional` is true.
-  public func optionalWrapped<TypeNode: TypeSyntaxProtocol>(type: TypeNode) -> TypeSyntax {
+  public func optionalWrapped(type: some TypeSyntaxProtocol) -> TypeSyntax {
     if isOptional {
       return TypeSyntax(OptionalTypeSyntax(wrappedType: type))
     } else {
@@ -169,7 +169,7 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in an optional chaining depending on whether `isOptional` is true.
-  public func optionalChained<ExprNode: ExprSyntaxProtocol>(expr: ExprNode) -> ExprSyntax {
+  public func optionalChained(expr: some ExprSyntaxProtocol) -> ExprSyntax {
     if isOptional {
       return ExprSyntax(OptionalChainingExprSyntax(expression: expr))
     } else {
@@ -178,7 +178,7 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in a force unwrap expression depending on whether `isOptional` is true.
-  public func forceUnwrappedIfNeeded<ExprNode: ExprSyntaxProtocol>(expr: ExprNode) -> ExprSyntax {
+  public func forceUnwrappedIfNeeded(expr: some ExprSyntaxProtocol) -> ExprSyntax {
     if isOptional {
       return ExprSyntax(ForcedValueExprSyntax(expression: expr))
     } else {

@@ -24,7 +24,6 @@ let lookupTable = ArrayExprSyntax(leftSquare: .leftSquareBracketToken(trailingTr
 let keywordFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
-    @frozen  // FIXME: Not actually stable, works around a miscompile
     public enum Keyword: UInt8, Hashable
     """
   ) {

@@ -48,7 +48,6 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       for (name, choices) in enums {
         try EnumDeclSyntax(
           """
-          @frozen // FIXME: Not actually stable, works around a miscompile
           public enum \(raw: name): RawSyntaxNodeProtocol
           """
         ) {
@@ -72,7 +71,7 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
             }
           }
 
-          try InitializerDeclSyntax("public init?<T>(_ other: T) where T : RawSyntaxNodeProtocol") {
+          try InitializerDeclSyntax("public init?(_ other: some RawSyntaxNodeProtocol)") {
             for (swiftName, typeName) in choices {
               StmtSyntax(
                 """
@@ -145,7 +144,7 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
+        public init?(_ other: some RawSyntaxNodeProtocol) {
           guard Self.isKindOf(other.raw) else { return nil }
           self.init(unchecked: other.raw)
         }
@@ -155,7 +154,7 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       if node.isBase {
         DeclSyntax(
           """
-          public init<Node: Raw\(raw: node.name)NodeProtocol>(_ other: Node) {
+          public init(_ other: some Raw\(raw: node.name)NodeProtocol) {
             self.init(unchecked: other.raw)
           }
           """

@@ -157,7 +157,7 @@ let rawSyntaxValidationFile = try! SourceFileSyntax(leadingTrivia: copyrightHead
               DeclSyntax(
                 #"""
                 func assertNoError(_ nodeKind: SyntaxKind, _ index: Int, _ error: ValidationError?) {
-                  if let error = error {
+                  if let error {
                     let (file, line) = error.fileAndLine
                     assertionFailure("""
                       Error validating child at index \(index) of \(nodeKind):

@@ -63,7 +63,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       DeclSyntax(
         """
         /// Create a `\(raw: node.name)` node from a specialized syntax node.
-        public init<S: \(raw: node.name)Protocol>(_ syntax: S) {
+        public init(_ syntax: some \(raw: node.name)Protocol) {
           // We know this cast is going to succeed. Go through init(_: SyntaxData)
           // to do a sanity check and verify the kind matches in debug builds and get
           // maximum performance in release builds.
@@ -75,7 +75,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       DeclSyntax(
         """
         /// Create a `\(raw: node.name)` node from a specialized optional syntax node.
-        public init?<S: \(raw: node.name)Protocol>(_ syntax: S?) {
+        public init?(_ syntax: (some \(raw: node.name)Protocol)?) {
           guard let syntax = syntax else { return nil }
           self.init(syntax)
         }
@@ -103,7 +103,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         """
       )
 
-      try InitializerDeclSyntax("public init?<S: SyntaxProtocol>(_ node: S)") {
+      try InitializerDeclSyntax("public init?(_ node: some SyntaxProtocol)") {
         try SwitchExprSyntax("switch node.raw.kind") {
           SwitchCaseListSyntax {
             SwitchCaseSyntax(

@@ -54,7 +54,6 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       if let collectionElementChoices = node.collectionElementChoices, !collectionElementChoices.isEmpty {
         try EnumDeclSyntax(
           """
-          @frozen // FIXME: Not actually stable, works around a miscompile
           public enum Element: SyntaxChildChoices
           """
         ) {
@@ -81,7 +80,7 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
             if choiceNode.isBase {
               DeclSyntax(
                 """
-                public init<Node: \(raw: choiceNode.name)Protocol>(_ node: Node) {
+                public init(_ node: some \(raw: choiceNode.name)Protocol) {
                   self = .\(raw: choiceNode.swiftSyntaxKind)(\(raw: choiceNode.name)(node))
                 }
                 """
@@ -98,7 +97,7 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
             }
           }
 
-          try InitializerDeclSyntax("public init?<S: SyntaxProtocol>(_ node: S)") {
+          try InitializerDeclSyntax("public init?(_ node: some SyntaxProtocol)") {
             for choiceName in node.collectionElementChoices ?? [] {
               let choiceNode = SYNTAX_NODE_MAP[choiceName]!
               StmtSyntax(
@@ -144,7 +143,7 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        public init?<S: SyntaxProtocol>(_ node: S) {
+        public init?(_ node: some SyntaxProtocol) {
           guard node.raw.kind == .\(raw: node.swiftSyntaxKind) else { return nil }
           self._syntaxNode = node._syntaxNode
         }

@@ -19,7 +19,6 @@ let syntaxEnumFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// Enum to exhaustively switch over all different syntax nodes.
-    @frozen // FIXME: Not actually stable, works around a miscompile
     public enum SyntaxEnum
     """
   ) {

@@ -19,7 +19,6 @@ let syntaxKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// Enumerates the known kinds of Syntax represented in the Syntax tree.
-    @frozen // FIXME: Not actually stable, works around a miscompile
     public enum SyntaxKind
     """
   ) {

@@ -58,7 +58,7 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax {
 
         DeclSyntax(
           """
-          public init?<S: SyntaxProtocol>(_ node: S) {
+          public init?(_ node: some SyntaxProtocol) {
             guard node.raw.kind == .\(raw: node.swiftSyntaxKind) else { return nil }
             self._syntaxNode = node._syntaxNode
           }
@@ -77,7 +77,7 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax {
           """
         )
 
-        try! InitializerDeclSyntax("\(node.generateInitializerDeclHeader(optionalBaseAsMissing: false))") {
+        try! InitializerDeclSyntax("\(node.generateInitializerDeclHeader())") {
           let parameters = ClosureParameterListSyntax {
             for child in node.children {
               ClosureParameterSyntax(firstName: .identifier(child.swiftName))
@@ -149,53 +149,6 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax {
           ExprSyntax("self.init(data)")
         }
 
-        if node.hasOptionalBaseTypeChild {
-          // TODO: Remove when we no longer support compiling in Swift 5.6. Change the
-          // above constructor to use `Optional<BaseType>.none` instead.
-          try! InitializerDeclSyntax(
-            """
-            /// This initializer exists solely because Swift 5.6 does not support
-            /// `Optional<ConcreteType>.none` as a default value of a generic parameter.
-            /// The above initializer thus defaults to `nil` instead, but that means it
-            /// is not actually callable when either not passing the defaulted parameter,
-            /// or passing `nil`.
-            ///
-            /// Hack around that limitation using this initializer, which takes a
-            /// `Missing*` syntax node instead. `Missing*` is used over the base type as
-            /// the base type would allow implicit conversion from a string literal,
-            /// which the above initializer doesn't support.
-            \(node.generateInitializerDeclHeader(optionalBaseAsMissing: true))
-            """
-          ) {
-            FunctionCallExprSyntax(callee: ExprSyntax("self.init")) {
-              TupleExprElementSyntax(label: "leadingTrivia", expression: ExprSyntax("leadingTrivia"))
-              for child in node.children {
-                if child.hasOptionalBaseType {
-                  TupleExprElementSyntax(
-                    leadingTrivia: .newline,
-                    label: .identifier(child.swiftName),
-                    colon: .colonToken(),
-                    expression: ExprSyntax("Optional<\(raw: child.typeName)>.none")
-                  )
-                } else if child.isUnexpectedNodes {
-                  TupleExprElementSyntax(
-                    leadingTrivia: .newline,
-                    expression: ExprSyntax("\(raw: child.swiftName)")
-                  )
-                } else {
-                  TupleExprElementSyntax(
-                    leadingTrivia: .newline,
-                    label: .identifier(child.swiftName),
-                    colon: .colonToken(),
-                    expression: ExprSyntax("\(raw: child.swiftName)")
-                  )
-                }
-              }
-              TupleExprElementSyntax(label: "trailingTrivia", expression: ExprSyntax("trailingTrivia"))
-            }
-          }
-        }
-
         for (index, child) in node.children.enumerated() {
           // ===================
           // Children properties
@@ -306,7 +259,7 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt
       if let choiceNode = SYNTAX_NODE_MAP[choice.syntaxKind], choiceNode.isBase {
         DeclSyntax(
           """
-          public init<Node: \(raw: choiceNode.name)Protocol>(_ node: Node) {
+          public init(_ node: some \(raw: choiceNode.name)Protocol) {
             self = .\(raw: choice.swiftName)(\(raw: choiceNode.name)(node))
           }
           """
@@ -323,7 +276,7 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt
       }
     }
 
-    try! InitializerDeclSyntax("public init?<S: SyntaxProtocol>(_ node: S)") {
+    try! InitializerDeclSyntax("public init?(_ node: some SyntaxProtocol)") {
       for choice in choices {
         StmtSyntax(
           """
@@ -353,49 +306,35 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt
 }
 
 fileprivate extension Node {
-  func generateInitializerDeclHeader(optionalBaseAsMissing: Bool) -> PartialSyntaxNodeString {
+  func generateInitializerDeclHeader() -> PartialSyntaxNodeString {
     if children.isEmpty {
       return "public init()"
     }
 
-    var genericParamNames: [String: Int] = [:]
-    var genericParams: [String] = []
-
     func createFunctionParameterSyntax(for child: Child) -> FunctionParameterSyntax {
-      var paramType: String
+      var paramType: TypeSyntax
       if !child.kind.isNodeChoicesEmpty {
-        paramType = child.name
+        paramType = "\(raw: child.name)"
       } else if child.hasBaseType {
-        if optionalBaseAsMissing {
-          paramType = "Missing\(child.typeName)"
-        } else {
-          // If we have a base type, make the initializer generic over its
-          // protocol instead.
-          let index = child.swiftName.index(child.swiftName.startIndex, offsetBy: 1)
-          paramType = child.swiftName[..<index].uppercased()
-
-          let paramCount = (genericParamNames[paramType] ?? 0) + 1
-          genericParamNames[paramType] = paramCount
-
-          if paramCount > 1 {
-            paramType += "\(paramCount)"
-          }
-          genericParams.append("\(paramType): \(child.typeName)Protocol")
-        }
+        paramType = "some \(raw: child.typeName)Protocol"
       } else {
-        paramType = child.typeName
+        paramType = "\(raw: child.typeName)"
       }
 
       if child.isOptional {
-        paramType += "?"
+        if paramType.is(ConstrainedSugarTypeSyntax.self) {
+          paramType = "(\(paramType))?"
+        } else {
+          paramType = "\(paramType)?"
+        }
       }
 
       return FunctionParameterSyntax(
         leadingTrivia: .newline,
         firstName: child.isUnexpectedNodes ? .wildcardToken(trailingTrivia: .space) : .identifier(child.swiftName),
         secondName: child.isUnexpectedNodes ? .identifier(child.swiftName) : nil,
         colon: .colonToken(),
-        type: TypeSyntax(stringLiteral: paramType),
+        type: paramType,
         defaultArgument: child.defaultInitialization
       )
     }
@@ -411,26 +350,10 @@ fileprivate extension Node {
         .with(\.leadingTrivia, .newline)
     }
 
-    if genericParams.isEmpty {
-      return """
-        public init(
-        \(params)
-        )
-        """
-    } else {
-      let generics = GenericParameterClauseSyntax(
-        genericParameterList: GenericParameterListSyntax {
-          for param in genericParams {
-            GenericParameterSyntax(name: .identifier(param))
-          }
-        }
+    return """
+      public init(
+      \(params)
       )
-
-      return """
-        public init\(generics)(
-        \(params)
-        )
-        """
-    }
+      """
   }
 }
@@ -316,7 +316,7 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
           }
         }
 
-        if let newLayout = newLayout {
+        if let newLayout {
           // A child node was rewritten. Build the updated node.
 
           // Sanity check, ensure the new children are the same length.

@@ -96,15 +96,15 @@ let syntaxTransformFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
     DeclSyntax(
       """
-      public func visit<T: SyntaxChildChoices>(_ node: T) -> ResultType {
+      public func visit(_ node: some SyntaxChildChoices) -> ResultType {
         return visit(Syntax(node))
       }
       """
     )
 
     DeclSyntax(
       """
-      public func visitChildren<SyntaxType: SyntaxProtocol>(_ node: SyntaxType) -> [ResultType] {
+      public func visitChildren(_ node: some SyntaxProtocol) -> [ResultType] {
         let syntaxNode = Syntax(node)
         return NonNilRawSyntaxChildren(syntaxNode, viewMode: .sourceAccurate).map { rawChild in
           let child = Syntax(SyntaxData(rawChild, parent: syntaxNode))