Fix debugInitCall

I broke `debugInitCall` when I removed the custom mirrors for syntax nodes. Fix it again, also fixing some more issues along the way that previously caused us to generate Swift code that didn’t compile.

Author: ahoppen

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/ChildNameForKeyPathFile.swift

@@ -20,7 +20,8 @@ let childNameForKeyPathFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     """
     /// If the keyPath is one from a layout structure, return the property name
     /// of it.
-    internal func childName(_ keyPath: AnyKeyPath) -> String?
+    @_spi(RawSyntax)
+    public func childName(_ keyPath: AnyKeyPath) -> String?
     """
   ) {
     try! SwitchExprSyntax("switch keyPath") {

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -14,7 +14,8 @@
 
 /// If the keyPath is one from a layout structure, return the property name
 /// of it.
-internal func childName(_ keyPath: AnyKeyPath) -> String? {
+@_spi(RawSyntax)
+public func childName(_ keyPath: AnyKeyPath) -> String? {
   switch keyPath {
   case \AccessPathComponentSyntax.unexpectedBeforeName:
     return "unexpectedBeforeName"

Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift

@@ -103,26 +103,57 @@ private extension Trivia {
   }
 }
 
+#if DEBUG
+/// We call into the Swift runtime to get the fully-qualified description of a
+/// type name in `debugInitCall`. This is fine-ish for two reaons:
+///  - The runtime is part of the ABI and is thus stable
+///  - We are only using this in a debug function that shouldn’t be called in
+///    any production app.
+@_silgen_name("swift_getTypeName")
+private func _getTypeName(_ type: Any.Type, qualified: Bool) -> (UnsafePointer<UInt8>, Int)
+
+private func getTypeName(_ type: Any.Type, qualified: Bool) -> String? {
+  let typeName = _getTypeName(type, qualified: true)
+  let buffer = UnsafeBufferPointer(start: typeName.0, count: typeName.1)
+  return String(decoding: buffer, as: UTF8.self)
+}
+
 extension SyntaxProtocol {
   /// Returns a Swift expression that, when parsed, constructs this syntax node
   /// (or at least an expression that's very close to constructing this node, the addition of a few manual upcast by hand is still needed).
   /// The intended use case for this is to print a syntax tree and create a substructure assertion from the generated expression.
   /// When `includeTrivia` is set to `false`, the token's leading and trailing trivia will not be included in the generated expression.
+  ///
+  /// - Warning: This is only designed for use in the debugger. Do not call it outside of the debugger.
+  @available(*, deprecated, message: "For use in debugger only")
   public func debugInitCall(includeTrivia: Bool = true) -> String {
     return self.debugInitCallExpr(includeTrivia: includeTrivia).formatted(using: InitializerExprFormat()).description
   }
 
   private func debugInitCallExpr(includeTrivia: Bool) -> ExprSyntax {
-    let mirror = Mirror(reflecting: self)
-    if self.kind.isSyntaxCollection {
+    if type(of: self) != self.syntaxNodeType {
+      let nestedInitCall = Syntax(self).asProtocol(SyntaxProtocol.self).debugInitCallExpr(includeTrivia: includeTrivia)
+      if var typeName = getTypeName(type(of: self), qualified: true) {
+        if typeName.hasPrefix("SwiftSyntax.") {
+          typeName = String(typeName.dropFirst("SwiftSyntax.".count))
+        }
+        return ExprSyntax(
+          FunctionCallExprSyntax(callee: ExprSyntax("\(raw: typeName)")) {
+            TupleExprElementSyntax(expression: nestedInitCall)
+          }
+        )
+      }
+      return nestedInitCall
+    }
+
+    if case .collection(let collectionElementType) = self.syntaxNodeType.structure {
       let typeName = String(describing: type(of: self))
       return ExprSyntax(
         FunctionCallExprSyntax(callee: IdentifierExprSyntax(identifier: .identifier(typeName))) {
           TupleExprElementSyntax(
             expression: ArrayExprSyntax {
-              for child in mirror.children {
-                let value = child.value as! SyntaxProtocol?
-                ArrayElementSyntax(expression: value?.debugInitCallExpr(includeTrivia: includeTrivia) ?? ExprSyntax(NilLiteralExprSyntax()))
+              for child in self.children(viewMode: .all) {
+                ArrayElementSyntax(expression: child.as(collectionElementType)!.debugInitCallExpr(includeTrivia: includeTrivia))
               }
             }
           )
@@ -132,12 +163,12 @@ extension SyntaxProtocol {
       let tokenKind = token.tokenKind
       let tokenInitializerName: String
       let tokenKindArgument: ExprSyntax?
-      if tokenKind.isLexerClassifiedKeyword || tokenKind == .eof {
-        tokenInitializerName = String(describing: tokenKind)
-        tokenKindArgument = nil
-      } else if case .keyword(let keyword) = tokenKind {
+      if case .keyword(let keyword) = tokenKind {
         tokenInitializerName = "keyword"
         tokenKindArgument = ExprSyntax(".\(raw: keyword)")
+      } else if tokenKind.isLexerClassifiedKeyword || tokenKind == .eof {
+        tokenInitializerName = String(describing: tokenKind)
+        tokenKindArgument = nil
       } else if tokenKind.decomposeToRaw().rawKind.defaultText != nil {
         tokenInitializerName = "\(String(describing: tokenKind))Token"
         tokenKindArgument = nil
@@ -174,15 +205,15 @@ extension SyntaxProtocol {
           }
         }
       )
-    } else {
+    } else if case .layout(let layout) = self.syntaxNodeType.structure {
       let typeName = String(describing: type(of: self))
       return ExprSyntax(
         FunctionCallExprSyntax(callee: IdentifierExprSyntax(identifier: .identifier(typeName))) {
-          for child in mirror.children {
-            let label = child.label!
-            let value = child.value as! SyntaxProtocol?
+          for keyPath in layout {
+            let label = childName(keyPath) ?? ""
+            let value = self[keyPath: keyPath as! PartialKeyPath<Self>] as! SyntaxProtocol?
             let isUnexpected = label.hasPrefix("unexpected")
-            if !isUnexpected || value != nil {
+            if value != nil {
               TupleExprElementSyntax(
                 label: isUnexpected ? nil : .identifier(label),
                 colon: isUnexpected ? nil : .colonToken(),
@@ -192,6 +223,10 @@ extension SyntaxProtocol {
           }
         }
       )
+    } else {
+      fatalError()
     }
   }
 }
+
+#endif