Rewrite Format to recursively format an entire SwiftSyntax tree

Previously, `Format` required very delicate interaction with SwiftSyntaxBuilder because it did not format a syntax tree recursively. This tight coupling was difficult to understand and even harder to describe. With the new split, `SwiftBasicFormat` can also be used outside of SwiftSyntaxBuilder.

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift

@@ -253,7 +253,7 @@ public let SYNTAX_TOKENS: [TokenSpec] = [
   StmtKeywordSpec(name: "Fallthrough", serializationCode: 35, text: "fallthrough", requiresTrailingSpace: true),
   StmtKeywordSpec(name: "Switch", serializationCode: 36, text: "switch", requiresTrailingSpace: true),
   StmtKeywordSpec(name: "Case", serializationCode: 37, text: "case", requiresTrailingSpace: true),
-  StmtKeywordSpec(name: "Default", serializationCode: 38, text: "default", requiresTrailingSpace: true),
+  StmtKeywordSpec(name: "Default", serializationCode: 38, text: "default"),
   StmtKeywordSpec(name: "Where", serializationCode: 39, text: "where", requiresLeadingSpace: true, requiresTrailingSpace: true),
   StmtKeywordSpec(name: "Catch", serializationCode: 40, text: "catch", requiresLeadingSpace: true),
   StmtKeywordSpec(name: "Throw", serializationCode: 50, text: "throw", requiresTrailingSpace: true),

CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift

@@ -35,20 +35,12 @@ public 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: ExpressibleAsExprBuildable, formatName: String) -> ExpressibleAsExprBuildable {
+  func generateExprBuildSyntaxNode(varName: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
     if type.isToken {
-      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: type.optionalChained(expr: varName), name: "buildToken")) {
-        TupleExprElement(label: "format", expression: "format")
-      }
+      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: type.optionalChained(expr: varName), name: "buildToken"))
     } else {
-      var format: ExpressibleAsExprBuildable = formatName
-      if isIndented {
-        format = MemberAccessExpr(base: format, name: "_indented")
-      }
       let expr = type.optionalChained(expr: varName)
-      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: expr, name: "build\(type.baseName)")) {
-        TupleExprElement(label: "format", expression: format)
-      }
+      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: expr, name: "build\(type.baseName)"))
     }
   }
 

CodeGeneration/Sources/generate-swiftbasicformat/BasicFormatFile.swift

@@ -0,0 +1,205 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SyntaxSupport
+import Utils
+
+let basicFormatFile = SourceFile {
+  ImportDecl(
+    leadingTrivia: .docLineComment(copyrightHeader),
+    path: "SwiftSyntax"
+  )
+
+  ClassDecl(modifiers: [Token.open], identifier: "BasicFormat", inheritanceClause: TypeInheritanceClause { InheritedType(typeName: "SyntaxRewriter") }) {
+    VariableDecl("public var indentationLevel: Int = 0")
+    VariableDecl("open var indentation: TriviaPiece { .spaces(indentationLevel * 4) }")
+    VariableDecl("private var indentedNewline: Trivia { Trivia(pieces: [.newlines(1), indentation]) }")
+    VariableDecl("private var lastRewrittenToken: TokenSyntax?")
+
+    for node in SYNTAX_NODES where !node.isBase {
+      if node.isSyntaxCollection {
+        makeSyntaxCollectionRewriteFunc(node: node)
+      } else {
+        makeLayoutNodeRewriteFunc(node: node)
+      }
+    }
+
+    createTokenFormatFunction()
+  }
+}
+
+private func makeLayoutNodeRewriteFunc(node: Node) -> FunctionDecl {
+  let rewriteResultType: String
+  if node.isSyntaxCollection {
+    rewriteResultType = "Syntax"
+  } else {
+    rewriteResultType = node.type.baseType?.syntaxBaseName ?? "Syntax"
+  }
+  return FunctionDecl(
+    leadingTrivia: .newline,
+    modifiers: [Token.open, Token(tokenSyntax: TokenSyntax.contextualKeyword("override", trailingTrivia: .space))],
+    identifier: .identifier("visit"),
+    signature: FunctionSignature(
+      input: ParameterClause(parameterList: [
+        FunctionParameter(
+          firstName: Token.wildcard,
+          secondName: .identifier("node"),
+          colon: .colon,
+          type: node.type.syntaxBaseName
+
+        )
+      ]),
+      output: rewriteResultType
+    )
+  ) {
+    for child in node.children {
+      if child.isIndented {
+        SequenceExpr("indentationLevel += 1")
+      }
+      let variableLetVar = child.requiresLeadingNewline ? "var" : "let"
+      if child.isOptional {
+        VariableDecl("\(variableLetVar) \(child.swiftName) = node.\(child.swiftName).map(self.visit)?.cast(\(child.type.syntaxBaseName).self)")
+      } else {
+        VariableDecl("\(variableLetVar) \(child.swiftName) = self.visit(node.\(child.swiftName)).cast(\(child.type.syntaxBaseName).self)")
+      }
+      if child.requiresLeadingNewline {
+        IfStmt(
+          """
+          if \(child.swiftName).leadingTrivia.first?.isNewline != true {
+            \(child.swiftName).leadingTrivia = indentedNewline + \(child.swiftName).leadingTrivia
+          }
+          """
+        )
+      }
+      if child.isIndented {
+        SequenceExpr("indentationLevel -= 1")
+      }
+    }
+    let reconstructed = FunctionCallExpr(calledExpression: "\(node.type.syntaxBaseName)") {
+      for child in node.children {
+        TupleExprElement(
+          label: child.isUnexpectedNodes ? nil : child.swiftName,
+          expression: child.swiftName
+        )
+      }
+    }
+    ReturnStmt("return \(rewriteResultType)(\(reconstructed))")
+  }
+}
+
+private func makeSyntaxCollectionRewriteFunc(node: Node) -> FunctionDecl {
+  let rewriteResultType: String
+  if node.isSyntaxCollection {
+    rewriteResultType = "Syntax"
+  } else {
+    rewriteResultType = node.type.baseType?.syntaxBaseName ?? "Syntax"
+  }
+  return FunctionDecl(
+    leadingTrivia: .newline,
+    modifiers: [Token.open, Token(tokenSyntax: TokenSyntax.contextualKeyword("override", trailingTrivia: .space))],
+    identifier: .identifier("visit"),
+    signature: FunctionSignature(
+      input: ParameterClause(parameterList: [
+        FunctionParameter(
+          firstName: Token.wildcard,
+          secondName: .identifier("node"),
+          colon: .colon,
+          type: node.type.syntaxBaseName
+
+        )
+      ]),
+      output: rewriteResultType
+    )
+  ) {
+    let formattedChildrenVarLet = node.elementsSeparatedByNewline ? "var" : "let"
+    VariableDecl(
+      """
+      \(formattedChildrenVarLet) formattedChildren = node.children(viewMode: .all).map {
+        self.visit($0).cast(\(node.collectionElementType.syntaxBaseName).self)
+      }
+      """
+    )
+    if node.elementsSeparatedByNewline {
+      SequenceExpr(
+        """
+        formattedChildren = formattedChildren.map {
+          if $0.leadingTrivia?.first?.isNewline == true {
+            return $0
+          } else {
+            return $0.withLeadingTrivia(indentedNewline + ($0.leadingTrivia ?? []))
+          }
+        }
+        """
+      )
+    }
+    ReturnStmt("return Syntax(\(node.type.syntaxBaseName)(formattedChildren))")
+  }
+}
+
+private func createTokenFormatFunction() -> FunctionDecl {
+  return FunctionDecl(
+    leadingTrivia: .newline,
+    modifiers: [Token.open, Token(tokenSyntax: TokenSyntax.contextualKeyword("override", trailingTrivia: .space))],
+    identifier: .identifier("visit"),
+    signature: FunctionSignature(
+      input: ParameterClause(parameterList: [
+        FunctionParameter(
+          firstName: Token.wildcard,
+          secondName: .identifier("node"),
+          colon: .colon,
+          type: "TokenSyntax"
+
+        )
+      ]),
+      output: "Syntax"
+    )
+  ) {
+    VariableDecl("var node = node")
+    SwitchStmt(expression: MemberAccessExpr(base: "node", name: "tokenKind")) {
+      for token in SYNTAX_TOKENS {
+        SwitchCase(label: SwitchCaseLabel(caseItems: CaseItem(pattern: ExpressionPattern(expression: MemberAccessExpr(name: token.swiftKind))))) {
+          if token.requiresLeadingSpace {
+            IfStmt(
+              """
+              if node.leadingTrivia.isEmpty && lastRewrittenToken?.trailingTrivia.isEmpty != false {
+                node.leadingTrivia += .space
+              }
+              """
+            )
+          }
+          if token.requiresTrailingSpace {
+            IfStmt(
+              """
+              if node.trailingTrivia.isEmpty {
+                node.trailingTrivia += .space
+              }
+              """
+            )
+          }
+          if !token.requiresLeadingSpace && !token.requiresTrailingSpace {
+            BreakStmt("break")
+          }
+        }
+      }
+      SwitchCase(label: SwitchCaseLabel(caseItems: CaseItem(pattern: ExpressionPattern(expression: MemberAccessExpr(name: "eof"))))) {
+        BreakStmt("break")
+      }
+    }
+    SequenceExpr("node.leadingTrivia = node.leadingTrivia.indented(indentation: indentation)")
+    SequenceExpr("node.trailingTrivia = node.trailingTrivia.indented(indentation: indentation)")
+    SequenceExpr("lastRewrittenToken = node")
+    ReturnStmt("return Syntax(node)")
+  }
+}