Significantly restrict nodes expressible by string interpolation

With this change the following nodes will be the only ones that are expressible by string interpolation:

- All base nodes
- `SourceFileSyntax`
- `AccessorDeclSyntax`
- `SwitchCase`

Most importantly, this removes the implicit expressibility by string literals for all decl/stmt/... nodes, which parsed the node as a decl/stmt/... and then cast it to the expected type.

New types now need to explicitly opt in to be expressible by string literals.

rdar://104090218

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/Node.swift

@@ -24,6 +24,7 @@ public class Node {
   public let description: String?
   public let baseKind: String
   public let parserFunction: String?
+  public let expressibleByStringLiteral: Bool
   public let traits: [String]
   public let children: [Child]
   public let nonUnexpectedChildren: [Child]
@@ -83,6 +84,7 @@ public class Node {
        kind: String,
        traits: [String] = [],
        parserFunction: String? = nil,
+       expressibleByStringLiteral: Bool = false,
        children: [Child] = [],
        element: String = "",
        elementName: String? = nil,
@@ -95,6 +97,7 @@ public class Node {
     self.nameForDiagnostics = nameForDiagnostics
     self.description = description
     self.parserFunction = parserFunction
+    self.expressibleByStringLiteral = expressibleByStringLiteral
     self.traits = traits
     self.baseKind = kind
 

CodeGeneration/Sources/SyntaxSupport/gyb_generated/AttributeNodes.swift

@@ -18,6 +18,7 @@ public let ATTRIBUTE_NODES: [Node] = [
        description: "An `@` attribute.",
        kind: "Syntax",
        parserFunction: "parseAttribute",
+       expressibleByStringLiteral: true,
        children: [
          Child(name: "AtSignToken",
                kind: "AtSignToken",

CodeGeneration/Sources/SyntaxSupport/gyb_generated/CommonNodes.swift

@@ -16,27 +16,32 @@ public let COMMON_NODES: [Node] = [
   Node(name: "Decl",
        nameForDiagnostics: "declaration",
        kind: "Syntax",
-       parserFunction: "parseDeclaration"),
+       parserFunction: "parseDeclaration",
+       expressibleByStringLiteral: true),
 
   Node(name: "Expr",
        nameForDiagnostics: "expression",
        kind: "Syntax",
-       parserFunction: "parseExpression"),
+       parserFunction: "parseExpression",
+       expressibleByStringLiteral: true),
 
   Node(name: "Stmt",
        nameForDiagnostics: "statement",
        kind: "Syntax",
-       parserFunction: "parseStatement"),
+       parserFunction: "parseStatement",
+       expressibleByStringLiteral: true),
 
   Node(name: "Type",
        nameForDiagnostics: "type",
        kind: "Syntax",
-       parserFunction: "parseType"),
+       parserFunction: "parseType",
+       expressibleByStringLiteral: true),
 
   Node(name: "Pattern",
        nameForDiagnostics: "pattern",
        kind: "Syntax",
-       parserFunction: "parsePattern"),
+       parserFunction: "parsePattern",
+       expressibleByStringLiteral: true),
 
   Node(name: "Missing",
        nameForDiagnostics: nil,

CodeGeneration/Sources/SyntaxSupport/gyb_generated/DeclNodes.swift

@@ -721,6 +721,7 @@ public let DECL_NODES: [Node] = [
          "WithStatements"
        ],
        parserFunction: "parseSourceFile",
+       expressibleByStringLiteral: true,
        children: [
          Child(name: "Statements",
                kind: "CodeBlockItemList",
@@ -1063,6 +1064,7 @@ public let DECL_NODES: [Node] = [
          "Attributed"
        ],
        parserFunction: "parseAccessorDecl",
+       expressibleByStringLiteral: true,
        children: [
          Child(name: "Attributes",
                kind: "AttributeList",

CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift

@@ -571,6 +571,7 @@ public let STMT_NODES: [Node] = [
          "WithStatements"
        ],
        parserFunction: "parseSwitchCase",
+       expressibleByStringLiteral: true,
        children: [
          Child(name: "UnknownAttr",
                kind: "Attribute",

CodeGeneration/Sources/SyntaxSupport/gyb_helpers/utils.py

@@ -22,6 +22,8 @@ def make_swift_node(node):
 
   if node.parser_function:
     parameters += ['parserFunction: "%s"' % node.parser_function]
+  if node.expressible_by_string_literal:
+    parameters += ['expressibleByStringLiteral: true']
 
   if node.non_unexpected_children:
     children = []

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/SyntaxExpressibleByStringInterpolationConformancesFile.swift

@@ -35,38 +35,8 @@ let syntaxExpressibleByStringInterpolationConformancesFile = SourceFileSyntax {
       """)
   }
 
-  for node in SYNTAX_NODES {
-    if node.isBase {
-      ExtensionDeclSyntax("extension \(raw: node.name)Protocol") {
-        InitializerDeclSyntax(
-          """
-          public init(stringInterpolationOrThrow stringInterpolation: SyntaxStringInterpolation) throws {
-            self = try performParse(source: stringInterpolation.sourceText, parse: { parser in
-              let node = \(raw: node.name).parse(from: &parser)
-              guard let result = node.as(Self.self) else {
-                throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualType: node.kind.syntaxNodeType)
-              }
-              return result
-            })
-          }
-          """)
-      }
-    }
-
-    if node.parserFunction != nil {
-      ExtensionDeclSyntax("extension \(raw: node.name): SyntaxExpressibleByStringInterpolation") {
-        InitializerDeclSyntax(
-          """
-          public init(stringInterpolationOrThrow stringInterpolation: SyntaxStringInterpolation) throws {
-            self = try performParse(source: stringInterpolation.sourceText, parse: { parser in
-              return Self.parse(from: &parser)
-            })
-          }
-          """)
-      }
-    } else if !node.isMissing && node.baseType.baseName != "Syntax" && node.baseType.baseName != "SyntaxCollection" {
-      ExtensionDeclSyntax("extension \(raw: node.name): SyntaxExpressibleByStringInterpolation { }")
-    }
+  for node in SYNTAX_NODES where node.expressibleByStringLiteral {
+    ExtensionDeclSyntax("extension \(raw: node.name): SyntaxExpressibleByStringInterpolation {}")
   }
 
   FunctionDeclSyntax(

Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift

@@ -408,7 +408,7 @@ extension VariableDeclSyntax {
     attributes: AttributeListSyntax? = nil,
     modifiers: ModifierListSyntax? = nil,
     _ letOrVarKeyword: Keyword,
-    name: IdentifierPatternSyntax,
+    name: PatternSyntax,
     type: TypeAnnotationSyntax? = nil,
     initializer: InitializerClauseSyntax? = nil
   ) {
@@ -431,7 +431,7 @@ extension VariableDeclSyntax {
     leadingTrivia: Trivia = [],
     attributes: AttributeListSyntax? = nil,
     modifiers: ModifierListSyntax? = nil,
-    name: IdentifierPatternSyntax,
+    name: PatternSyntax,
     type: TypeAnnotationSyntax,
     @CodeBlockItemListBuilder accessor: () -> CodeBlockItemListSyntax
   ) {

Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift

@@ -150,6 +150,10 @@ enum SyntaxStringInterpolationError: Error, CustomStringConvertible {
   case producedInvalidNodeType(expectedType: SyntaxProtocol.Type, actualType: SyntaxProtocol.Type)
   case diagnostics([Diagnostic], tree: Syntax)
 
+  static func producedInvalidNodeType<S: SyntaxProtocol>(expectedType: SyntaxProtocol.Type, actualNode: S) -> Self {
+    return .producedInvalidNodeType(expectedType: expectedType, actualType: type(of: actualNode))
+  }
+
   var description: String {
     switch self {
     case .producedInvalidNodeType(expectedType: let expectedType, actualType: let actualType):

Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift

@@ -12,6 +12,8 @@
 
 import SwiftSyntax
 
+// MARK: - Error
+
 // MARK: - PartialSyntaxNode
 
 /// A type that is expressible by string interpolation the same way that syntax
@@ -39,16 +41,22 @@ extension SyntaxStringInterpolation {
 
 public protocol HasTrailingCodeBlock {
   var body: CodeBlockSyntax { get set }
+
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) throws
 }
 
-public extension HasTrailingCodeBlock where Self: SyntaxExpressibleByStringInterpolation {
-  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) {
-    self = "\(signature) {}"
+public extension HasTrailingCodeBlock where Self: StmtSyntaxProtocol {
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) throws {
+    let stmt = StmtSyntax("\(signature) {}")
+    guard let castedStmt = stmt.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: stmt)
+    }
+    self = castedStmt
     self.body = CodeBlockSyntax(statements: bodyBuilder())
   }
 }
 
-extension CatchClauseSyntax: HasTrailingCodeBlock {}
+//extension CatchClauseSyntax: HasTrailingCodeBlock {}
 extension DeferStmtSyntax: HasTrailingCodeBlock {}
 extension DoStmtSyntax: HasTrailingCodeBlock {}
 extension ForInStmtSyntax: HasTrailingCodeBlock {}
@@ -59,11 +67,17 @@ extension WhileStmtSyntax: HasTrailingCodeBlock {}
 
 public protocol HasTrailingOptionalCodeBlock {
   var body: CodeBlockSyntax? { get set }
+
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) throws
 }
 
-public extension HasTrailingOptionalCodeBlock where Self: SyntaxExpressibleByStringInterpolation {
-  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) {
-    self = "\(signature) {}"
+public extension HasTrailingOptionalCodeBlock where Self: DeclSyntaxProtocol {
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax) throws {
+    let decl = DeclSyntax("\(signature) {}")
+    guard let castedDecl = decl.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: decl)
+    }
+    self = castedDecl
     self.body = CodeBlockSyntax(statements: bodyBuilder())
   }
 }
@@ -77,11 +91,17 @@ extension InitializerDeclSyntax: HasTrailingOptionalCodeBlock {}
 
 public protocol HasTrailingMemberDeclBlock {
   var members: MemberDeclBlockSyntax { get set }
+
+  init(_ signature: PartialSyntaxNodeString, @MemberDeclListBuilder membersBuilder: () -> MemberDeclListSyntax) throws
 }
 
-public extension HasTrailingMemberDeclBlock where Self: SyntaxExpressibleByStringInterpolation {
-  init(_ signature: PartialSyntaxNodeString, @MemberDeclListBuilder membersBuilder: () -> MemberDeclListSyntax) {
-    self = "\(signature) {}"
+public extension HasTrailingMemberDeclBlock where Self: DeclSyntaxProtocol {
+  init(_ signature: PartialSyntaxNodeString, @MemberDeclListBuilder membersBuilder: () -> MemberDeclListSyntax) throws {
+    let decl = DeclSyntax("\(signature) {}")
+    guard let castedDecl = decl.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: decl)
+    }
+    self = castedDecl
     self.members = MemberDeclBlockSyntax(members: membersBuilder())
   }
 }
@@ -98,15 +118,23 @@ extension StructDeclSyntax: HasTrailingMemberDeclBlock {}
 // So we cannot conform to `HasTrailingCodeBlock`
 
 public extension IfStmtSyntax {
-  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, @CodeBlockItemListBuilder `else` elseBuilder: () -> CodeBlockItemListSyntax? = { nil }) {
-    self = "\(signature) {}"
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, @CodeBlockItemListBuilder `else` elseBuilder: () -> CodeBlockItemListSyntax? = { nil }) throws {
+    let stmt = StmtSyntax("\(signature) {}")
+    guard let ifStmt = stmt.as(IfStmtSyntax.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: stmt)
+    }
+    self = ifStmt
     self.body = CodeBlockSyntax(statements: bodyBuilder())
     self.elseBody = elseBuilder().map { .codeBlock(CodeBlockSyntax(statements: $0)) }
     self.elseKeyword = elseBody != nil ? .keyword(.else) : nil
   }
 
-  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfStmtSyntax) {
-    self = "\(signature) {}"
+  init(_ signature: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfStmtSyntax) throws {
+    let stmt = StmtSyntax("\(signature) {}")
+    guard let ifStmt = stmt.as(IfStmtSyntax.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: stmt)
+    }
+    self = ifStmt
     self.body = CodeBlockSyntax(statements: bodyBuilder())
     self.elseBody = .ifStmt(elseIf)
     self.elseKeyword = elseBody != nil ? .keyword(.else) : nil
@@ -118,8 +146,12 @@ public extension IfStmtSyntax {
 // So we cannot conform to `HasTrailingCodeBlock` or `HasTrailingMemberDeclBlock`
 
 public extension SwitchStmtSyntax {
-  init(_ signature: PartialSyntaxNodeString, @SwitchCaseListBuilder casesBuilder: () -> SwitchCaseListSyntax = { SwitchCaseListSyntax([]) }) {
-    self = "\(signature) {}"
+  init(_ signature: PartialSyntaxNodeString, @SwitchCaseListBuilder casesBuilder: () -> SwitchCaseListSyntax = { SwitchCaseListSyntax([]) }) throws {
+    let stmt = StmtSyntax("\(signature) {}")
+    guard let castedStmt = stmt.as(Self.self) else {
+      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: IfStmtSyntax.self, actualNode: stmt)
+    }
+    self = castedStmt
     self.cases = casesBuilder()
   }
 }