Generate ExpressibleByStringInterpolation conformances using gyb

Author: ahoppen

Sources/SwiftParser/Parser.swift

@@ -43,7 +43,7 @@ extension Parser {
     // be alive until `Syntax(raw:)` retains the arena.
     return withExtendedLifetime(parser) {
       let rawSourceFile =  parser.parseSourceFile()
-      return Syntax(raw: rawSourceFile.raw).as(SourceFileSyntax.self)!
+      return rawSourceFile.syntax
     }
   }
 }

Sources/SwiftParser/Syntax+StringInterpolation.swift

@@ -142,68 +142,3 @@ extension SyntaxExpressibleByStringInterpolation {
     self.init(stringInterpolation: interpolation)
   }
 }
-
-private func castRawToSyntaxNode<OutputType: SyntaxProtocol, RawType: RawSyntaxNodeProtocol>(_ raw: RawType) -> OutputType {
-  let syntax = Syntax(raw: raw.raw)
-  guard let result = syntax.as(OutputType.self) else {
-    fatalError("Parsing was expected to produce a \(OutputType.self) but produced \(type(of: syntax.asProtocol(SyntaxProtocol.self)))")
-  }
-  return result
-}
-
-// Parsing support for the main kinds of syntax nodes.
-extension DeclSyntaxProtocol {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parseDeclaration())
-  }
-}
-
-extension ExprSyntaxProtocol {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parseExpression())
-  }
-}
-
-extension StmtSyntaxProtocol {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parseStatement())
-  }
-}
-
-extension TypeSyntaxProtocol {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parseType())
-  }
-}
-
-extension PatternSyntaxProtocol {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parsePattern())
-  }
-}
-
-// String interpolation support for the primary node kinds.
-extension SourceFileSyntax: SyntaxExpressibleByStringInterpolation {
-  public static func parse(from parser: inout Parser) -> Self {
-    return castRawToSyntaxNode(parser.parseSourceFile())
-  }
-}
-
-extension DeclSyntax: SyntaxExpressibleByStringInterpolation { }
-extension ExprSyntax: SyntaxExpressibleByStringInterpolation { }
-extension StmtSyntax: SyntaxExpressibleByStringInterpolation { }
-extension TypeSyntax: SyntaxExpressibleByStringInterpolation { }
-extension PatternSyntax: SyntaxExpressibleByStringInterpolation { }
-extension FunctionDeclSyntax: SyntaxExpressibleByStringInterpolation { }
-extension ReturnStmtSyntax: SyntaxExpressibleByStringInterpolation { }
-extension SwitchStmtSyntax: SyntaxExpressibleByStringInterpolation { }
-extension FunctionSignatureSyntax: SyntaxExpressibleByStringInterpolation {
-  public static func parse(from parser: inout Parser) -> SwiftSyntax.FunctionSignatureSyntax {
-    return castRawToSyntaxNode(parser.parseFunctionSignature())
-  }
-}
-extension SwitchCaseSyntax: SyntaxExpressibleByStringInterpolation {
-  public static func parse(from parser: inout Parser) -> SwiftSyntax.SwitchCaseSyntax {
-    return castRawToSyntaxNode(parser.parseSwitchCase())
-  }
-}

Sources/SwiftParser/SyntaxExpressilbeByStringInterpolationConformances.swift.gyb

@@ -0,0 +1,65 @@
+%{
+  from gyb_syntax_support import *
+  NODE_MAP = create_node_map()
+  # -*- mode: Swift -*-
+  # Ignore the following admonition it applies to the resulting .swift file only
+}%
+//// Automatically Generated From SyntaxExpressilbeByStringInterpolationConformances.swift.gyb.
+//// Do Not Edit Directly!
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(RawSyntax) import SwiftSyntax
+
+% STRING_INTERPOLATION_BASE_KINDS = [base_kind for base_kind in SYNTAX_BASE_KINDS if base_kind != 'Syntax' and base_kind != 'SyntaxCollection']
+% for base_kind in STRING_INTERPOLATION_BASE_KINDS:
+%   node = NODE_MAP[base_kind]
+extension ${base_kind}SyntaxProtocol {
+  public static func parse(from parser: inout Parser) -> Self {
+    let node = parser.${node.parser_function}().syntax
+    guard let result = node.as(Self.self) else {
+      fatalError("Parsing was expected to produce a \(Self.self) but produced \(type(of: node.asProtocol(${base_kind}SyntaxProtocol.self)))")
+    }
+    return result
+  }
+}
+
+% end
+
+%{
+def parser_invocation(node):
+  if node.kind == 'Expr':
+    return "return ExprSyntax(parser.parseExpression().syntax).castOrFatalError(Self.self)"
+  elif node.kind == 'Stmt':
+    return "return StmtSyntax(parser.parseStatement().syntax).castOrFatalError(Self.self)"
+  elif node.kind == 'Type':
+    return "return TypeSyntax(parser.parseType().syntax).castOrFatalError(Self.self)"
+  elif node.kind == 'Pattern':
+    return "return PatternSyntax(parser.parsePattern().syntax).castOrFatalError(Self.self)"
+  elif node.parser_function is not None:
+    return f"return parser.{node.parser_function}().syntax"
+  else:
+    return None
+}%
+% for node in SYNTAX_NODES:
+%   if node.kind in STRING_INTERPOLATION_BASE_KINDS:
+extension ${node.name}: SyntaxExpressibleByStringInterpolation {}
+
+%   elif node.parser_function:
+extension ${node.name}: SyntaxExpressibleByStringInterpolation {
+  public static func parse(from parser: inout Parser) -> Self {
+    return parser.${node.parser_function}().syntax
+  }
+}
+
+%   end
+% end