[SwiftParser] Improve ergonomics for initializers of RawXXXSyntax

CodeGeneration/Sources/generate-swift-syntax/templates/swiftparser/LayoutNodesParsableFile.swift

@@ -65,13 +65,11 @@ let layoutNodesParsableFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
           // The missing item is not necessary to be a declaration,
           // which is just a placeholder here
           return RawCodeBlockItemSyntax(
-            item: .decl(
-              RawDeclSyntax(
-                RawMissingDeclSyntax(
-                  attributes: self.emptyCollection(RawAttributeListSyntax.self),
-                  modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
-                  arena: self.arena
-                )
+            item: .init(
+              decl: RawMissingDeclSyntax(
+                attributes: self.emptyCollection(RawAttributeListSyntax.self),
+                modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
+                arena: self.arena
               )
             ),
             semicolon: nil,

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift

@@ -102,6 +102,18 @@ func rawSyntaxNodesFile(nodesStartingWith: [Character]) -> SourceFileSyntax {
 
               StmtSyntax("return nil")
             }
+
+            for (swiftName, kind) in choices {
+              if let choiceNode = SYNTAX_NODE_MAP[kind], choiceNode.kind.isBase {
+                DeclSyntax(
+                  """
+                  public init(\(swiftName): some \(choiceNode.kind.rawProtocolType)) {
+                    self = .\(swiftName)(\(choiceNode.kind.rawType)(\(swiftName)))
+                  }
+                  """
+                )
+              }
+            }
           }
         }
 
@@ -270,9 +282,16 @@ func rawSyntaxNodesFile(nodesStartingWith: [Character]) -> SourceFileSyntax {
 
 fileprivate extension Child {
   var rawParameterType: TypeSyntax {
-    let paramType: TypeSyntax
-    if case ChildKind.nodeChoices = kind {
-      paramType = syntaxChoicesType
+    var paramType: TypeSyntax
+    if !kind.isNodeChoicesEmpty {
+      paramType = "\(syntaxChoicesType)"
+    } else if hasBaseType && !isOptional {
+      // we restrict the use of generic type to non-optional parameter types, otherwise call sites would no longer be
+      // able to just pass `nil` to this parameter without specializing `(some Raw<Kind>SyntaxNodeProtocol)?`
+      //
+      // we've opted out of providing a default value to the parameter (e.g. `RawExprSyntax?.none`) as a workaround,
+      // as passing an explicit `nil` would prompt developers to think clearly whether this parameter should be parsed
+      paramType = "some \(syntaxNodeKind.rawProtocolType)"
     } else {
       paramType = syntaxNodeKind.rawType
     }

Sources/SwiftParser/Attributes.swift

@@ -361,9 +361,7 @@ extension Parser {
           unexpectedBeforeAtSign,
           atSign: atSign,
           unexpectedBeforeAttributeName,
-          attributeName: RawTypeSyntax(
-            RawIdentifierTypeSyntax(name: attributeName, genericArgumentClause: nil, arena: self.arena)
-          ),
+          attributeName: RawIdentifierTypeSyntax(name: attributeName, genericArgumentClause: nil, arena: self.arena),
           leftParen: nil,
           arguments: nil,
           rightParen: nil,
@@ -394,13 +392,11 @@ extension RawLabeledExprSyntax {
     self.init(
       label: nil,
       colon: nil,
-      expression: RawExprSyntax(
-        RawDeclReferenceExprSyntax(
-          unexpectedBeforeIdentifier,
-          baseName: identifier,
-          argumentNames: nil,
-          arena: arena
-        )
+      expression: RawDeclReferenceExprSyntax(
+        unexpectedBeforeIdentifier,
+        baseName: identifier,
+        argumentNames: nil,
+        arena: arena
       ),
       unexpectedBetweenIdentifierAndTrailingComma,
       trailingComma: trailingComma,
@@ -448,9 +444,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSign: atSign,
       unexpectedBeforeDifferentiable,
-      attributeName: RawTypeSyntax(
-        RawIdentifierTypeSyntax(name: differentiable, genericArgumentClause: nil, arena: self.arena)
-      ),
+      attributeName: RawIdentifierTypeSyntax(name: differentiable, genericArgumentClause: nil, arena: self.arena),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       arguments: .differentiableArguments(argument),
@@ -592,9 +586,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSign: atSign,
       unexpectedBeforeDerivative,
-      attributeName: RawTypeSyntax(
-        RawIdentifierTypeSyntax(name: derivative, genericArgumentClause: nil, arena: self.arena)
-      ),
+      attributeName: RawIdentifierTypeSyntax(name: derivative, genericArgumentClause: nil, arena: self.arena),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       arguments: .derivativeRegistrationArguments(argument),
@@ -616,9 +608,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSign: atSign,
       unexpectedBeforeTranspose,
-      attributeName: RawTypeSyntax(
-        RawIdentifierTypeSyntax(name: transpose, genericArgumentClause: nil, arena: self.arena)
-      ),
+      attributeName: RawIdentifierTypeSyntax(name: transpose, genericArgumentClause: nil, arena: self.arena),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       arguments: .derivativeRegistrationArguments(argument),

Sources/SwiftParser/CollectionNodes+Parsable.swift

@@ -81,11 +81,11 @@ extension AccessorDeclListSyntax: SyntaxParseable {
 extension AttributeListSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     return parse(from: &parser) { parser in
-      return RawSyntax(parser.parseAttributeList())
+      return parser.parseAttributeList()
     } makeMissing: { remainingTokens, arena in
       return RawAttributeSyntax(
         atSign: RawTokenSyntax(missing: .atSign, arena: arena),
-        attributeName: RawTypeSyntax(RawMissingTypeSyntax(arena: arena)),
+        attributeName: RawMissingTypeSyntax(arena: arena),
         leftParen: nil,
         arguments: nil,
         rightParen: nil,
@@ -99,18 +99,21 @@ extension CodeBlockItemListSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     return parse(from: &parser) { parser in
       let node = parser.parseCodeBlockItemList(until: { _ in false })
-      return RawSyntax(node)
+      return node
     } makeMissing: { remainingTokens, arena in
-      let missingExpr = RawMissingExprSyntax(arena: arena)
-      return RawCodeBlockItemSyntax(item: .expr(RawExprSyntax(missingExpr)), semicolon: nil, arena: arena)
+      RawCodeBlockItemSyntax(
+        item: .init(expr: RawMissingExprSyntax(arena: arena)),
+        semicolon: nil,
+        arena: arena
+      )
     }
   }
 }
 
 extension MemberBlockItemListSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     return parse(from: &parser) { parser in
-      return RawSyntax(parser.parseMemberDeclList())
+      return parser.parseMemberDeclList()
     } makeMissing: { remainingTokens, arena in
       let missingDecl = RawMissingDeclSyntax(
         attributes: RawAttributeListSyntax(elements: [], arena: arena),
@@ -119,7 +122,7 @@ extension MemberBlockItemListSyntax: SyntaxParseable {
         RawUnexpectedNodesSyntax(remainingTokens, arena: arena),
         arena: arena
       )
-      return RawMemberBlockItemSyntax(decl: RawDeclSyntax(missingDecl), semicolon: nil, arena: arena)
+      return RawMemberBlockItemSyntax(decl: missingDecl, semicolon: nil, arena: arena)
     }
   }
 }

Sources/SwiftParser/Declarations.swift

@@ -534,9 +534,9 @@ extension Parser {
             RawGenericRequirementSyntax(
               requirement: .sameTypeRequirement(
                 RawSameTypeRequirementSyntax(
-                  leftType: RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena)),
+                  leftType: RawMissingTypeSyntax(arena: self.arena),
                   equal: missingToken(.binaryOperator, text: "=="),
-                  rightType: RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena)),
+                  rightType: RawMissingTypeSyntax(arena: self.arena),
                   arena: self.arena
                 )
               ),
@@ -674,7 +674,7 @@ extension Parser {
             RawSameTypeRequirementSyntax(
               leftType: firstType,
               equal: RawTokenSyntax(missing: .binaryOperator, text: "==", arena: self.arena),
-              rightType: RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena)),
+              rightType: RawMissingTypeSyntax(arena: self.arena),
               arena: self.arena
             )
           )
@@ -722,12 +722,10 @@ extension Parser {
     if let remainingTokens = remainingTokensIfMaximumNestingLevelReached() {
       let item = RawMemberBlockItemSyntax(
         remainingTokens,
-        decl: RawDeclSyntax(
-          RawMissingDeclSyntax(
-            attributes: self.emptyCollection(RawAttributeListSyntax.self),
-            modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
-            arena: self.arena
-          )
+        decl: RawMissingDeclSyntax(
+          attributes: self.emptyCollection(RawAttributeListSyntax.self),
+          modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
+          arena: self.arena
         ),
         semicolon: nil,
         arena: self.arena
@@ -1558,7 +1556,7 @@ extension Parser {
     let unexpectedBeforeEqual: RawUnexpectedNodesSyntax?
     let equal: RawTokenSyntax
     if let colon = self.consume(if: .colon) {
-      unexpectedBeforeEqual = RawUnexpectedNodesSyntax(elements: [RawSyntax(colon)], arena: self.arena)
+      unexpectedBeforeEqual = RawUnexpectedNodesSyntax([colon], arena: self.arena)
       equal = missingToken(.equal)
     } else {
       (unexpectedBeforeEqual, equal) = self.expect(.equal)

Sources/SwiftParser/Directives.swift

@@ -75,7 +75,7 @@ extension Parser {
 
     // Parse #if
     let (unexpectedBeforePoundIf, poundIf) = self.expect(.poundIf)
-    let condition = RawExprSyntax(self.parseSequenceExpression(flavor: .poundIfDirective))
+    let condition = self.parseSequenceExpression(flavor: .poundIfDirective)
     let unexpectedBetweenConditionAndElements = self.consumeRemainingTokenOnLine()
 
     clauses.append(
@@ -102,7 +102,7 @@ extension Parser {
       switch match {
       case .poundElseif:
         (unexpectedBeforePound, pound) = self.eat(handle)
-        condition = RawExprSyntax(self.parseSequenceExpression(flavor: .poundIfDirective))
+        condition = self.parseSequenceExpression(flavor: .poundIfDirective)
         unexpectedBetweenConditionAndElements = self.consumeRemainingTokenOnLine()
       case .poundElse:
         (unexpectedBeforePound, pound) = self.eat(handle)
@@ -114,7 +114,7 @@ extension Parser {
             arena: self.arena
           )
           pound = self.missingToken(.poundElseif)
-          condition = RawExprSyntax(self.parseSequenceExpression(flavor: .poundIfDirective))
+          condition = self.parseSequenceExpression(flavor: .poundIfDirective)
         } else {
           condition = nil
         }
@@ -132,7 +132,7 @@ extension Parser {
             arena: self.arena
           )
           pound = self.missingToken(.poundElseif)
-          condition = RawExprSyntax(self.parseSequenceExpression(flavor: .poundIfDirective))
+          condition = self.parseSequenceExpression(flavor: .poundIfDirective)
           unexpectedBetweenConditionAndElements = self.consumeRemainingTokenOnLine()
         } else {
           break LOOP