Generalize generation of raw choices enum

Author: ahoppen

Sources/SwiftSyntax/Raw/RawSyntaxNodes.swift.gyb

@@ -29,38 +29,42 @@ public protocol Raw${node.name}NodeProtocol: Raw${node.base_type}NodeProtocol {}
 
 @_spi(RawSyntax)
 public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_type}NodeProtocol, RawSyntaxToSyntax {
+%   enums = []
 %   for child in node.children:
 %     if child.node_choices:
-  public enum ${child.name}: RawSyntaxNodeProtocol {
-%       for choice in child.node_choices:
-    case `${choice.swift_name}`(Raw${choice.type_name})
-%       end
+%       enums.append((child.name, [(choice.swift_name, choice.type_name) for choice in child.node_choices]))
+%     end
+%   end
+%   for (name, choices) in enums:
+  public enum ${name}: RawSyntaxNodeProtocol {
+%     for (swift_name, type_name) in choices:
+    case `${swift_name}`(Raw${type_name})
+%     end
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return ${" || ".join([f"Raw{choice.type_name}.isKindOf(raw)" for choice in child.node_choices])}
+      return ${" || ".join([f"Raw{type_name}.isKindOf(raw)" for (swift_name, type_name) in choices])}
     }
 
     public var raw: RawSyntax {
       switch self {
-%       for choice in child.node_choices:
-      case .${choice.swift_name}(let node): return node.raw
-%       end
+%     for (swift_name, type_name) in choices:
+      case .${swift_name}(let node): return node.raw
+%     end
       }
     }
 
     public init?<T>(_ other: T) where T : RawSyntaxNodeProtocol {
-%       for choice in child.node_choices:
-      if let node = Raw${choice.type_name}(other) {
-        self = .${choice.swift_name}(node)
+%     for (swift_name, type_name) in choices:
+      if let node = Raw${type_name}(other) {
+        self = .${swift_name}(node)
         return
       }
-%       end
+%     end
       return nil
     }
   }
-%     end
-%   end
 
+%   end
   public typealias SyntaxType = ${node.name}
 
   @_spi(RawSyntax)