Replace optionalQuestionMark with SwiftSyntaxBuilder nodes

fwcd · fwcd · commit ab059e98c737 · 2022-08-04T03:26:30.000+02:00
diff --git a/Sources/SwiftSyntaxBuilderGeneration/SyntaxBuildableChild.swift b/Sources/SwiftSyntaxBuilderGeneration/SyntaxBuildableChild.swift
@@ -10,6 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
 /// Extension to the `Child` type to provide functionality specific to
 /// SwiftSyntaxBuilder.
 extension Child {
@@ -31,17 +34,37 @@ extension Child {
   /// Generate a Swift expression that creates a proper SwiftSyntax node of type
   /// `type.syntax` from a variable named `varName` of type `type.buildable` that
   /// represents this child node.
-  func generateExprBuildSyntaxNode(varName: String, formatName: String) -> String {
+  func generateExprBuildSyntaxNode(varName: String, formatName: String) -> ExpressibleAsExprBuildable {
     if type.isToken {
       if requiresLeadingNewline {
-        return "\(varName).withLeadingTrivia(.newline + \(formatName)._makeIndent() + (\(varName).leadingTrivia ?? []))"
+        return FunctionCallExpr(MemberAccessExpr(base: varName, name: "withLeadingTrivia")) {
+          SequenceExpr {
+            MemberAccessExpr(name: "newline")
+            BinaryOperatorExpr("+")
+            FunctionCallExpr(MemberAccessExpr(base: formatName, name: "_makeIndent"))
+            BinaryOperatorExpr("+")
+            TupleExpr {
+              SequenceExpr {
+                MemberAccessExpr(base: varName, name: "leadingTrivia")
+                BinaryOperatorExpr("??")
+                ArrayExpr(elements: [])
+              }
+            }
+          }
+        }
       } else {
         return varName
       }
     } else {
-      let format = formatName + (isIndented ? "._indented()" : "")
-      let expr = "\(varName)\(type.optionalQuestionMark)"
-      return "\(expr).build\(type.baseName)(format: \(format), leadingTrivia: nil)"
+      var format: ExpressibleAsExprBuildable = formatName
+      if isIndented {
+        format = FunctionCallExpr(MemberAccessExpr(base: format, name: "_indented"))
+      }
+      let expr = type.optionalChained(expr: varName)
+      return FunctionCallExpr(MemberAccessExpr(base: expr, name: "build\(type.baseName)")) {
+        TupleExprElement(label: "format", expression: format)
+        TupleExprElement(label: "leadingTrivia", expression: "nil")
+      }
     }
   }
 
diff --git a/Sources/SwiftSyntaxBuilderGeneration/SyntaxBuildableType.swift b/Sources/SwiftSyntaxBuilderGeneration/SyntaxBuildableType.swift
@@ -22,11 +22,6 @@ struct SyntaxBuildableType: Hashable {
   let tokenKind: String?
   let isOptional: Bool
 
-  /// If optional `?`, otherwise the empty string.
-  var optionalQuestionMark: String {
-    isOptional ? "?" : ""
-  }
-
   /// Whether this is a token.
   var isToken: Bool {
     syntaxKind == "Token"
@@ -71,81 +66,98 @@ struct SyntaxBuildableType: Hashable {
     syntaxKind
   }
 
-  /// Return the name of the `Buildable` type that is the main entry point for building
+  /// Return the `Buildable` type that is the main entry point for building
   /// SwiftSyntax trees using `SwiftSyntaxBuilder`.
   ///
   /// These names look as follows:
   ///  - For nodes: The node name, e.g. `IdentifierExpr` (these are implemented as structs)
   ///  - For base kinds: `<BaseKind>Buildable`, e.g. `ExprBuildable` (these are implemented as protocols)
   ///  - For token: `TokenSyntax` (tokens don't have a dedicated type in SwiftSyntaxBuilder)
-  /// If the type is optional, this terminates with a '?'.
-  var buildable: String {
-    if isToken {
-      // Tokens don't have a dedicated buildable type.
-      return "TokenSyntax\(optionalQuestionMark)"
-    } else if SYNTAX_BASE_KINDS.contains(syntaxKind) {
-      return "\(syntaxKind)Buildable\(optionalQuestionMark)"
-    } else {
-      return "\(syntaxKind)\(optionalQuestionMark)"
-    }
+  /// If the type is optional, the type is wrapped in an `OptionalType`.
+  var buildable: ExpressibleAsTypeBuildable {
+    optionalWrapped(type: buildableBaseName)
   }
 
   /// Whether parameters of this type should be initializable by a result builder.
   /// Used for certain syntax collections and block-like structures (e.g. `CodeBlock`,
   /// `MemberDeclList`).
   var isBuilderInitializable: Bool {
-    BUILDER_INITIALIZABLE_TYPES.keys.contains(nonOptional.buildable)
+    BUILDER_INITIALIZABLE_TYPES.keys.contains(buildableBaseName)
   }
 
   /// A type suitable for initializing this type through a result builder (e.g.
   /// returns `CodeBlockItemList` for `CodeBlock`) and otherwise itself.
   var builderInitializableType: Self {
-    let buildable = nonOptional.buildable
-    return Self(
-      syntaxKind: BUILDER_INITIALIZABLE_TYPES[buildable].flatMap { $0 } ?? buildable,
+    Self(
+      syntaxKind: BUILDER_INITIALIZABLE_TYPES[buildableBaseName].flatMap { $0 } ?? buildableBaseName,
       isOptional: isOptional
     )
   }
 
   /// The type from `buildable()` without any question marks attached.
   /// This is used for the `create*` methods defined in the `ExpressibleAs*` protocols.
   var buildableBaseName: String {
-    nonOptional.buildable
+    if isToken {
+      // Tokens don't have a dedicated buildable type.
+      return "TokenSyntax"
+    } else if SYNTAX_BASE_KINDS.contains(syntaxKind) {
+      return "\(syntaxKind)Buildable"
+    } else {
+      return syntaxKind
+    }
   }
 
-  /// The `ExpressibleAs*` Swift type for this syntax kind. Tokens don't
-  /// have an `ExpressibleAs*` type, so for those this method just returns
-  /// `TokenSyntax`. If the type is optional, this terminates with a `?`.
-  var expressibleAs: String {
+  /// The `ExpressibleAs*` Swift type for this syntax kind without any
+  /// question marks attached.
+  var expressibleAsBaseName: String {
     if isToken {
       // Tokens don't have a dedicated ExpressibleAs type.
-      return buildable
+      return buildableBaseName
     } else {
-      return "ExpressibleAs\(buildable)"
+      return "ExpressibleAs\(buildableBaseName)"
     }
   }
 
+  /// The `ExpressibleAs*` Swift type for this syntax kind. Tokens don't
+  /// have an `ExpressibleAs*` type, so for those this method just returns
+  /// `TokenSyntax`. If the type is optional, this terminates with a `?`.
+  var expressibleAs: ExpressibleAsTypeBuildable {
+    optionalWrapped(type: expressibleAsBaseName)
+  }
+
   /// The corresponding `*Syntax` type defined in the `SwiftSyntax` module,
-  /// which will eventually get built from `SwiftSyntaxBuilder`. If the type
-  /// is optional, this terminates with a `?`.
-  var syntax: String {
+  /// without any question marks attached.
+  var syntaxBaseName: String {
     if syntaxKind == "Syntax" {
-      return "Syntax\(optionalQuestionMark)"
+      return "Syntax"
     } else {
-      return "\(syntaxKind)Syntax\(optionalQuestionMark)"
+      return "\(syntaxKind)Syntax"
     }
   }
 
-  /// Assuming that this is a base kind, return the corresponding `*ListBuildable` type.
-  var listBuildable: String {
+  /// The corresponding `*Syntax` type defined in the `SwiftSyntax` module,
+  /// which will eventually get built from `SwiftSyntaxBuilder`. If the type
+  /// is optional, this terminates with a `?`.
+  var syntax: ExpressibleAsTypeBuildable {
+    optionalWrapped(type: syntaxBaseName)
+  }
+
+  /// Assuming that this is a base kind, return the corresponding `*ListBuildable` type
+  /// without any question marks attached.
+  var listBuildableBaseName: String {
     assert(SYNTAX_BASE_KINDS.contains(syntaxKind), "ListBuildable types only exist for syntax base kinds")
-    return "\(syntaxKind)ListBuildable\(optionalQuestionMark)"
+    return "\(syntaxKind)ListBuildable"
+  }
+
+  /// Assuming that this is a base kind, return the corresponding `*ListBuildable` type.
+  var listBuildable: ExpressibleAsTypeBuildable {
+    optionalWrapped(type: listBuildableBaseName)
   }
 
   /// Assuming that this is a collection type, the type of the result builder
   /// that can be used to build the collection.
-  var resultBuilder: String {
-    "\(syntaxKind)Builder\(optionalQuestionMark)"
+  var resultBuilder: ExpressibleAsTypeBuildable {
+    optionalWrapped(type: "\(syntaxKind)Builder")
   }
 
   /// The collection types in which this type occurs as an element.
@@ -167,7 +179,7 @@ struct SyntaxBuildableType: Hashable {
   /// make the `ExpressibleAs*` of this type conform to the `ExpressibleAs*`
   /// protocol of the convertible types.
   var convertibleToTypes: [Self] {
-    (SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES[buildable] ?? [])
+    (SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES[buildableBaseName] ?? [])
       .map { Self(syntaxKind: $0) }
   }
 
@@ -220,13 +232,31 @@ struct SyntaxBuildableType: Hashable {
     }
   }
 
+  /// Wraps a type in an optional depending on whether `isOptional` is true.
+  func optionalWrapped(type: ExpressibleAsTypeBuildable) -> ExpressibleAsTypeBuildable {
+    if isOptional {
+      return OptionalType(wrappedType: type)
+    } else {
+      return type
+    }
+  }
+
+  /// Wraps a type in an optional chaining depending on whether `isOptional` is true.
+  func optionalChained(expr: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
+    if isOptional {
+      return OptionalChainingExpr(expression: expr)
+    } else {
+      return expr
+    }
+  }
+
   /// Generate an expression that converts a variable named `varName`
   /// which is of `expressibleAs` type to an object of type `buildable`.
-  func generateExprConvertParamTypeToStorageType(varName: String) -> String {
+  func generateExprConvertParamTypeToStorageType(varName: String) -> ExpressibleAsExprBuildable {
     if isToken {
       return varName
     } else {
-      return "\(varName)\(optionalQuestionMark).create\(buildableBaseName)()"
+      return FunctionCallExpr(MemberAccessExpr(base: optionalChained(expr: varName), name: "create\(buildableBaseName)"))
     }
   }
 }
diff --git a/Sources/SwiftSyntaxBuilderGeneration/Templates/BuildableBaseProtocolsFile.swift b/Sources/SwiftSyntaxBuilderGeneration/Templates/BuildableBaseProtocolsFile.swift
@@ -30,67 +30,67 @@ let buildableBaseProtocolsFile = SourceFile {
     let syntaxType = SyntaxBuildableType(syntaxKind: "Syntax")
     let isSyntax = type == syntaxType
     // Types that the `*Buildable` conforms to
-    let buildableConformances: [String] = [type.expressibleAs, type.listBuildable] + (isSyntax ? [] : [syntaxType.buildable])
-    let listConformances: [String] = isSyntax ? [] : [syntaxType.listBuildable]
+    let buildableConformances: [String] = [type.expressibleAsBaseName, type.listBuildableBaseName] + (isSyntax ? [] : [syntaxType.buildableBaseName])
+    let listConformances: [String] = isSyntax ? [] : [syntaxType.listBuildableBaseName]
 
     ProtocolDecl(
       modifiers: [TokenSyntax.public],
-      identifier: type.listBuildable,
+      identifier: type.listBuildableBaseName,
       inheritanceClause: createTypeInheritanceClause(conformances: listConformances)
     ) {
       FunctionDecl(
         leadingTrivia: [
-          "/// Builds list of `\(type.syntax)`s.",
+          "/// Builds list of `\(type.syntaxBaseName)`s.",
           "/// - Parameter format: The `Format` to use.",
           "/// - Parameter leadingTrivia: Replaces the last leading trivia if not nil.",
         ].map { .docLineComment($0) + .newline }.reduce([], +),
         identifier: .identifier("build\(type.baseName)List"),
         signature: FunctionSignature(
           input: formatLeadingTriviaParameters(),
-          output: ArrayType(elementType: type.syntax)
+          output: ArrayType(elementType: type.syntaxBaseName)
         ),
         body: nil
       )
     }
 
     ProtocolDecl(
       modifiers: [TokenSyntax.public],
-      identifier: type.buildable,
+      identifier: type.buildableBaseName,
       inheritanceClause: createTypeInheritanceClause(conformances: buildableConformances)
     ) {
       FunctionDecl(
         leadingTrivia: [
-          "/// Builds list of `\(type.syntax)`s.",
+          "/// Builds list of `\(type.syntaxBaseName)`s.",
           "/// - Parameter format: The `Format` to use.",
           "/// - Parameter leadingTrivia: Replaces the last leading trivia if not nil.",
         ].map { .docLineComment($0) + .newline }.reduce([], +),
         identifier: .identifier("build\(type.baseName)"),
         signature: FunctionSignature(
           input: formatLeadingTriviaParameters(),
-          output: type.syntax
+          output: type.syntaxBaseName
         ),
         body: nil
       )
     }
 
     ExtensionDecl(
       modifiers: [TokenSyntax.public],
-      extendedType: type.buildable
+      extendedType: type.buildableBaseName
     ) {
       FunctionDecl(
-        leadingTrivia: .docLineComment("/// Satisfies conformance to `\(type.expressibleAs)`.") + .newline,
+        leadingTrivia: .docLineComment("/// Satisfies conformance to `\(type.expressibleAsBaseName)`.") + .newline,
         identifier: .identifier("create\(type.buildableBaseName)"),
         signature: FunctionSignature(
           input: ParameterClause(),
-          output: type.buildable
+          output: type.buildableBaseName
         )
       ) {
         ReturnStmt(expression: "self")
       }
 
       FunctionDecl(
         leadingTrivia: [
-          "/// Builds list of `\(type.syntax)`s.",
+          "/// Builds list of `\(type.syntaxBaseName)`s.",
           "/// - Parameter format: The `Format` to use.",
           "/// - Parameter leadingTrivia: Replaces the last leading trivia if not nil.",
           "///",
@@ -99,7 +99,7 @@ let buildableBaseProtocolsFile = SourceFile {
         identifier: .identifier("build\(type.baseName)List"),
         signature: FunctionSignature(
           input: formatLeadingTriviaParameters(withDefaultTrivia: true),
-          output: ArrayType(elementType: type.syntax)
+          output: ArrayType(elementType: type.syntaxBaseName)
         )
       ) {
         ReturnStmt(expression: ArrayExpr {
@@ -113,10 +113,10 @@ let buildableBaseProtocolsFile = SourceFile {
       if !isSyntax {
         FunctionDecl(
           leadingTrivia: [
-          "/// Builds a `\(type.syntax)`.",
+          "/// Builds a `\(type.syntaxBaseName)`.",
           "/// - Parameter format: The `Format` to use.",
           "/// - Parameter leadingTrivia: Replaces the last leading trivia if not nil.",
-          "/// - Returns: A new `Syntax` with the built `\(type.syntax)`.",
+          "/// - Returns: A new `Syntax` with the built `\(type.syntaxBaseName)`.",
           "///",
           "/// Satisfies conformance to `SyntaxBuildable`.",
         ].map { .docLineComment($0) + .newline }.reduce([], +),
diff --git a/Sources/SwiftSyntaxBuilderGeneration/Templates/ExpressibleAsProtocolsFile.swift b/Sources/SwiftSyntaxBuilderGeneration/Templates/ExpressibleAsProtocolsFile.swift
@@ -39,8 +39,8 @@ let expressibleAsProtocolsFile = SourceFile {
 
     ProtocolDecl(
       modifiers: [TokenSyntax.public],
-      identifier: type.expressibleAs,
-      inheritanceClause: createTypeInheritanceClause(conformances: declaredConformances.map(\.expressibleAs))
+      identifier: type.expressibleAsBaseName,
+      inheritanceClause: createTypeInheritanceClause(conformances: declaredConformances.map(\.expressibleAsBaseName))
     ) {
       FunctionDecl(
         identifier: .identifier("create\(type.buildableBaseName)"),
@@ -55,18 +55,18 @@ let expressibleAsProtocolsFile = SourceFile {
     if !conformances.isEmpty {
       ExtensionDecl(
         modifiers: [TokenSyntax.public],
-        extendedType: type.expressibleAs
+        extendedType: type.expressibleAsBaseName
       ) {
         for conformance in type.elementInCollections {
           FunctionDecl(
-            leadingTrivia: .docLineComment("/// Conformance to `\(conformance.expressibleAs)`") + .newline,
+            leadingTrivia: .docLineComment("/// Conformance to `\(conformance.expressibleAsBaseName)`") + .newline,
             identifier: .identifier("create\(conformance.buildableBaseName)"),
             signature: FunctionSignature(
               input: ParameterClause(),
               output: conformance.buildable
             )
           ) {
-            ReturnStmt(expression: FunctionCallExpr(conformance.buildable) {
+            ReturnStmt(expression: FunctionCallExpr(conformance.buildableBaseName) {
               TupleExprElement(expression: ArrayExpr {
                 ArrayElement(expression: "self")
               })
@@ -76,14 +76,14 @@ let expressibleAsProtocolsFile = SourceFile {
         for conformance in type.convertibleToTypes {
           let param = Node.from(type: conformance).singleNonDefaultedChild
           FunctionDecl(
-            leadingTrivia: .docLineComment("/// Conformance to \(conformance.expressibleAs)") + .newline,
+            leadingTrivia: .docLineComment("/// Conformance to \(conformance.expressibleAsBaseName)") + .newline,
             identifier: .identifier("create\(conformance.buildableBaseName)"),
             signature: FunctionSignature(
               input: ParameterClause(),
-              output: conformance.buildable
+              output: conformance.buildableBaseName
             )
           ) {
-            ReturnStmt(expression: FunctionCallExpr(conformance.buildable) {
+            ReturnStmt(expression: FunctionCallExpr(conformance.buildableBaseName) {
               TupleExprElement(label: param.swiftName, expression: "self")
             })
           }
diff --git a/Sources/SwiftSyntaxBuilderGeneration/Templates/TokenSyntaxFile.swift b/Sources/SwiftSyntaxBuilderGeneration/Templates/TokenSyntaxFile.swift
