Merge pull request #320 from kimdv/kimdv/introduce-protocols-conformance-map

Use protocols conformance map to add protocols

Author: ahoppen

Sources/SwiftSyntaxBuilder/BooleanLiteralExprConvenienceInitializers.swift

@@ -10,9 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SwiftSyntax
+
 extension BooleanLiteralExpr {
   public init(_ value: Bool) {
-    self.init(booleanLiteral: value ? .true : .false)
+    self.init(booleanLiteral: value ? TokenSyntax.true : .false)
   }
 }
 

Sources/SwiftSyntaxBuilder/Buildables.swift.gyb

@@ -3,6 +3,7 @@
   from gyb_syntax_support.kinds import lowercase_first_word
   from gyb_syntax_support.kinds import SYNTAX_BASE_KINDS
   from gyb_syntax_support.kinds import syntax_buildable_child_type, syntax_buildable_default_init_value
+  from gyb_syntax_support.protocolsMap import SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES
   # -*- mode: Swift -*-
   # Ignore the following admonition it applies to the resulting .swift file only
 }%
@@ -40,16 +41,18 @@ public protocol ${kind}ListBuildable: SyntaxListBuildable {
 }
 
 %     buildable_type = kind + 'Buildable'
-public protocol ExpressibleAs${buildable_type} {
+%     expressible_as_type = 'ExpressibleAs' + buildable_type
+%     expressible_as_protocols = SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES.get(expressible_as_type)
+%     if expressible_as_protocols:
+public protocol ${expressible_as_type}: ${', '.join(expressible_as_protocols)} {
+%     else:
+public protocol ${expressible_as_type} {
+%     end
   func create${buildable_type}() -> ${buildable_type}
 }
 
 %     if kind == 'Syntax':
 public protocol ${buildable_type}: ExpressibleAs${buildable_type}, ${kind}ListBuildable {
-%     elif kind == 'Decl':
-public protocol ${buildable_type}: ExpressibleAs${buildable_type}, SyntaxBuildable, ${kind}ListBuildable, ExpressibleAsMemberDeclListItem, ExpressibleAsCodeBlockItem {
-%     elif kind == 'Stmt':
-public protocol ${buildable_type}: ExpressibleAs${buildable_type}, SyntaxBuildable, ${kind}ListBuildable, ExpressibleAsCodeBlockItem {
 %     else:
 public protocol ${buildable_type}: ExpressibleAs${buildable_type}, SyntaxBuildable, ${kind}ListBuildable {
 %     end
@@ -97,22 +100,6 @@ extension ${buildable_type} {
     [build${kind}(format: format, leadingTrivia: leadingTrivia)]
   }
 }
-%     if kind == 'Decl':
-
-extension DeclBuildable {
-  public func createMemberDeclListItem() -> MemberDeclListItem { 
-    MemberDeclListItem(decl: self)
-  }
-}
-%     end
-%     if kind in ['Decl', 'Stmt']:
-
-extension ${kind}Buildable {
-  public func createCodeBlockItem() -> CodeBlockItem { 
-    CodeBlockItem(item: self)
-  }
-}
-%     end
 
 %   end
 % end
@@ -137,12 +124,15 @@ public struct ${node.syntax_kind}: ${node.base_kind}Buildable {
 %       child_token = SYNTAX_TOKEN_MAP.get(child.syntax_kind)
 %       param_type = syntax_buildable_child_type(child.type_name, child.syntax_kind, child.is_token(), child.is_optional)
 %       default_value = syntax_buildable_default_init_value(child, child_token)
-%       init_parameters.append("%s: %s%s" % (child.swift_name, param_type, default_value))
+%       init_parameters.append("%s: ExpressibleAs%s%s" % (child.swift_name, param_type, default_value))
 %     end
     ${',\n    '.join(init_parameters)}
   ) {
 %     for child in node.children:
-    self.${child.swift_name} = ${child.swift_name}
+%       create_method_dot = '?.' if child.is_optional else '.'
+%       child_token = SYNTAX_TOKEN_MAP.get(child.syntax_kind)
+%       param_type = syntax_buildable_child_type(child.type_name, child.syntax_kind, child.is_token())
+    self.${child.swift_name} = ${child.swift_name}${create_method_dot}create${param_type}()
 %     end
   }
 
@@ -198,8 +188,8 @@ public struct ${node.syntax_kind}: ${node.base_kind}Buildable {
 public struct ${node.syntax_kind}: SyntaxBuildable {
   let elements: [${element_type}]
 
-  public init(_ elements: [${element_type}]) {
-    self.elements = elements
+  public init(_ elements: [ExpressibleAs${element_type}]) {
+    self.elements = elements.map { $0.create${element_type}() }
   }
 
   public func build${node.syntax_kind}(format: Format) -> ${node.syntax_kind}Syntax {
@@ -229,11 +219,17 @@ public struct ${node.syntax_kind}: SyntaxBuildable {
 
 %   end
 %   if node.is_buildable() or node.is_syntax_collection():
-public protocol ExpressibleAs${node.syntax_kind} {
+%     expressible_as_type = 'ExpressibleAs' + node.syntax_kind
+%     expressible_as_protocols = SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES.get(expressible_as_type)
+%     if expressible_as_protocols:
+public protocol ${expressible_as_type}: ${', '.join(expressible_as_protocols)} {
+%     else:
+public protocol ${expressible_as_type} {
+%     end
   func create${node.syntax_kind}() -> ${node.syntax_kind}
 }
 
-extension ${node.syntax_kind}: ExpressibleAs${node.syntax_kind} {
+extension ${node.syntax_kind}: ${expressible_as_type} {
   public func create${node.syntax_kind}() -> ${node.syntax_kind} {
     self
   }
@@ -249,4 +245,41 @@ extension TokenSyntax: ExpressibleAsTokenSyntax {
   public func createTokenSyntax() -> TokenSyntax {
     self
   }
-}
+}
+
+// MARK: - Syntax buildable expressible as conformances
+
+% for protocol, conformances in SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES.items():
+%   if 'ExpressibleAsConditionElementList' in conformances:
+extension ${protocol} {
+  public func createConditionElementList() -> ConditionElementList {
+    ConditionElementList([self])
+  }
+}
+
+%   end
+%   if 'ExpressibleAsConditionElement' in conformances:
+extension ${protocol} {
+  public func createConditionElement() -> ConditionElement {
+    ConditionElement(condition: self)
+  }
+}
+
+%   end
+%   if 'ExpressibleAsCodeBlockItem' in conformances:
+extension ${protocol} {
+  public func createCodeBlockItem() -> CodeBlockItem {
+    CodeBlockItem(item: self)
+  }
+}
+
+%   end
+%   if 'ExpressibleAsMemberDeclListItem' in conformances:
+extension ${protocol} {
+  public func createMemberDeclListItem() -> MemberDeclListItem {
+    MemberDeclListItem(decl: self)
+  }
+}
+
+%   end
+% end

Sources/SwiftSyntaxBuilder/BuildablesConvenienceInitializers.swift.gyb

@@ -53,7 +53,7 @@ extension ${node.syntax_kind} {
 %           # When type is not handled above, use default value
 %           param_type = syntax_buildable_child_type(child.type_name, child.syntax_kind, child.is_token(), child.is_optional)
 %           default_value = syntax_buildable_default_init_value(child, child_token)
-%           init_parameters.append("%s: %s%s" % (child.swift_name, param_type, default_value))
+%           init_parameters.append("%s: ExpressibleAs%s%s" % (child.swift_name, param_type, default_value))
 %         end
 %       end
     ${',\n    '.join(init_parameters + init_result_builder_parameters)}

Sources/SwiftSyntaxBuilder/Tokens.swift.gyb

@@ -21,26 +21,30 @@
 import SwiftSyntax
 
 /// Namespace for commonly used tokens with default trivia.
-public extension TokenSyntax {
+public extension ExpressibleAsTokenSyntax where Self == TokenSyntax {
 % for token in SYNTAX_TOKENS:
 %   if token.is_keyword:
   /// The `${token.text.encode('utf-8').decode('unicode_escape')}` keyword
-  static let `${lowercase_first_word(token.name)}` = SyntaxFactory.make${token.name}Keyword()
+  static var `${lowercase_first_word(token.name)}`: TokenSyntax {
+    SyntaxFactory.make${token.name}Keyword()
 %   if token.requires_leading_space:
     .withLeadingTrivia(.spaces(1))
 %   end
 %   if token.requires_trailing_space:
     .withTrailingTrivia(.spaces(1))
+  }
 %   end
 %   elif token.text:
   /// The `${token.text.encode('utf-8').decode('unicode_escape')}` token
-  static let `${lowercase_first_word(token.name)}` = SyntaxFactory.make${token.name}Token()
+  static var `${lowercase_first_word(token.name)}`: TokenSyntax {
+    SyntaxFactory.make${token.name}Token()
 %   if token.requires_leading_space:
     .withLeadingTrivia(.spaces(1))
 %   end
 %   if token.requires_trailing_space:
     .withTrailingTrivia(.spaces(1))
 %   end
+  }
 %   else:
   static func `${lowercase_first_word(token.name)}`(_ text: String) -> TokenSyntax {
     SyntaxFactory.make${token.name}(text)
@@ -55,5 +59,7 @@ public extension TokenSyntax {
 
 % end
   /// The `eof` token
-  static let eof = SyntaxFactory.makeToken(.eof, presence: .present)
+  static var eof: TokenSyntax {
+    SyntaxFactory.makeToken(.eof, presence: .present)
+  }
 }