Add Buildable gyb

Author: kimdv

Sources/SwiftSyntaxBuilder/Buildables.swift.gyb

@@ -0,0 +1,172 @@
+%{
+  from gyb_syntax_support import *
+  from gyb_syntax_support.kinds import lowercase_first_word
+  from gyb_syntax_support.kinds import SYNTAX_BASE_KINDS
+  # -*- mode: Swift -*-
+  # Ignore the following admonition it applies to the resulting .swift file only
+
+  def syntax_buildable_child_type(syntax_kind, is_token=False, is_optional=False):
+    if syntax_kind in SYNTAX_BASE_KINDS:
+      buildable_type = syntax_kind + 'Buildable'
+    elif not is_token:
+      buildable_type = syntax_kind
+    elif 'List' in syntax_kind:
+      buildable_type = syntax_kind + 'Syntax'
+    else:
+      buildable_type = 'TokenSyntax'
+
+    if is_optional:
+      buildable_type += '?'
+
+    return buildable_type
+}%
+//// Automatically Generated From DeclBuildables.swift.gyb.
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+// MARK: Protocols
+
+% for kind in SYNTAX_BASE_KINDS:
+%   if kind != 'SyntaxCollection':
+%     build_kind = 'Syntax' if kind == 'Syntax' else kind + 'Syntax'
+%     if kind == 'Syntax':
+public protocol ${kind}ListBuildable {
+%     else:
+public protocol ${kind}ListBuildable: SyntaxListBuildable {
+%     end
+  func build${kind}List(format: Format, leadingTrivia: Trivia?) -> [${build_kind}]
+}
+
+%     if kind == 'Syntax':
+public protocol ${kind}Buildable: ${kind}ListBuildable {
+%     else:
+public protocol ${kind}Buildable: SyntaxBuildable, ${kind}ListBuildable {
+%     end
+  func build${kind}(format: Format, leadingTrivia: Trivia?) -> ${build_kind}
+}
+
+extension ${kind}Buildable {
+  public func buildSyntax(format: Format, leadingTrivia: Trivia?) -> Syntax {
+    Syntax(build${kind}(format: format, leadingTrivia: leadingTrivia))
+  }
+
+  public func build${kind}List(format: Format, leadingTrivia: Trivia?) -> [${build_kind}] {
+    [build${kind}(format: format, leadingTrivia: leadingTrivia)]
+  }
+}
+
+%   end
+% end
+
+// MARK: - Buildables
+
+% for node in SYNTAX_NODES:
+%   if node.is_buildable():
+%     return_type = 'Syntax'
+%     if node.base_kind != 'Syntax':
+%       return_type = node.base_kind + 'Syntax'
+%     end
+public struct ${node.syntax_kind}: ${node.base_kind}Buildable {
+%     child_params = []
+%     for child in node.children:
+%       param_type = syntax_buildable_child_type(child.syntax_kind, child.is_token(), child.is_optional)
+%       child_params.append("%s: %s" % (child.swift_name, param_type))
+%     end
+%     for child_param in child_params:
+  let ${child_param}
+%     end
+
+  public init(
+    ${',\n    '.join(child_params)}
+  ) {
+%     for child in node.children:
+    self.${child.swift_name} = ${child.swift_name}
+%     end
+  }
+  
+  func build${node.syntax_kind}(format: Format, leadingTrivia: Trivia?) -> ${node.syntax_kind}Syntax {
+%     child_params = []
+%     for child in node.children:
+%       param_name = child.swift_name
+%       if child.is_token() and child.requires_leading_newline:
+%         param_name = param_name + '.withLeadingTrivia(.newlines(1) + format._makeIndent())'
+%       elif child.syntax_kind in SYNTAX_BASE_KINDS or not child.is_token():
+%         if child.is_optional:
+%           param_name = param_name + "?"
+%         end
+%         format = 'format'
+%         if child.is_indented:
+%           format += '._indented()'
+%         end            
+%         param_name = param_name + ".build" + child.syntax_kind + "(format: " + format + ", leadingTrivia: nil)"
+%       end
+%       child_params.append("%s: %s" % (child.swift_name, param_name))
+%     end
+    let ${node.swift_syntax_kind} = SyntaxFactory.make${node.syntax_kind}(
+      ${',\n      '.join(child_params)}
+    )
+    
+    if let leadingTrivia = leadingTrivia {
+      return ${node.swift_syntax_kind}
+        .withLeadingTrivia(leadingTrivia)
+    }
+
+    return ${node.swift_syntax_kind}
+  }
+
+  public func build${node.base_kind}(format: Format, leadingTrivia: Trivia?) -> ${return_type} {
+    let ${node.swift_syntax_kind} = build${node.syntax_kind}(format: format, leadingTrivia: leadingTrivia)
+    return ${return_type}(${node.swift_syntax_kind})
+  }
+}
+
+%   elif node.is_syntax_collection():
+// MARK: - Syntax collection
+public struct ${node.syntax_kind}: SyntaxBuildable {
+// ${node.collection_element}
+%     element_type = syntax_buildable_child_type(node.collection_element, node.is_token())
+  let elements: [${element_type}]
+
+  public init(_ elements: [${element_type}]) {
+    self.elements = elements
+  }
+
+  public func build${node.syntax_kind}(format: Format, leadingTrivia: Trivia?) -> ${node.syntax_kind}Syntax {
+%     if not node.is_token():
+%       leading_trivia = 'nil'
+%       if node.elements_separated_by_newline:
+%         leading_trivia = '.newlines(1) + format._makeIndent()'
+%       end
+    let collection = SyntaxFactory.make${node.syntax_kind}(elements.map {
+      $0.build${node.collection_element}(format: format, leadingTrivia: ${leading_trivia})
+    })
+%     else:
+    let collection = SyntaxFactory.make${node.syntax_kind}(elements)
+%     end
+      return collection
+  }
+
+  public func buildSyntax(format: Format, leadingTrivia: Trivia?) -> Syntax {
+    let ${node.swift_syntax_kind} = build${node.syntax_kind}(format: format, leadingTrivia: leadingTrivia)
+
+    if let leadingTrivia = leadingTrivia {
+      return Syntax(${node.swift_syntax_kind}).withLeadingTrivia(leadingTrivia)
+    }
+
+    return Syntax(${node.swift_syntax_kind})
+  }
+}
+
+%   end
+% end