Pretty results of dump() for Syntax

The result of dump() with Syntax is not useful. For example,
the dumped result of Tests/SwiftSyntaxTest/Inputs/closure.swift is the following:

```
▿ // A closure without a signature. The test will ensure it stays the same after
// applying a rewriting pass.
let x: () -> Void = {}
  ▿ data: SwiftSyntax.SyntaxData
    - parent: nil
    ▿ absoluteRaw: SwiftSyntax.AbsoluteRawSyntax
      - raw: // A closure without a signature. The test will ensure it stays the same after
// applying a rewriting pass.
let x: () -> Void = {} #0
        ▿ super: Swift.ManagedBuffer<SwiftSyntax.RawSyntaxBase, Swift.UInt64>
          ▿ header: SwiftSyntax.RawSyntaxBase
	  ...
```

This patch improve this result to the following:

```
▿ SourceFileSyntax
  ▿ statements: CodeBlockItemListSyntax
    ▿ CodeBlockItemSyntax
      ▿ item: VariableDeclSyntax
        - attributes: nil
        - modifiers: nil
        ▿ letOrVarKeyword: TokenSyntax
          - text: "let"
          ▿ leadingTrivia: SwiftSyntax.Trivia
            ▿ pieces: 4 elements
              ▿ TriviaPiece
                - lineComment: "// A closure without a signature. The test will ensure it stays the same after"
                ...
```

Author: Kuniwak

Sources/SwiftSyntax/Syntax.swift

@@ -14,7 +14,7 @@
 /// Each node has accessors for its known children, and allows efficient
 /// iteration over the children through its `children` property.
 public protocol Syntax:
-  CustomStringConvertible, TextOutputStreamable {}
+  CustomStringConvertible, CustomDebugStringConvertible, TextOutputStreamable {}
 
 internal protocol _SyntaxBase: Syntax {
   /// The data backing this node.
@@ -262,6 +262,11 @@ extension _SyntaxBase {
     return s
   }
 
+  /// Returns a description used by dump.
+  public var debugDescription: String {
+    return "\(type(of: self))"
+  }
+
   /// Prints the raw value of this node to the provided stream.
   /// - Parameter stream: The stream to which to print the raw tree.
   public func write<Target>(to target: inout Target)
@@ -623,6 +628,17 @@ public struct TokenSyntax: _SyntaxBase, Hashable {
   }
 }
 
+extension TokenSyntax: CustomReflectable {
+  public var customMirror: Mirror {
+    return Mirror(self, children: [
+      "text": text,
+      "leadingTrivia": leadingTrivia,
+      "trailingTrivia": trailingTrivia,
+      "tokenKind": tokenKind,
+    ])
+  }
+}
+
 /// Sequence of tokens that are part of the provided Syntax node.
 public struct TokenSequence: Sequence {
   public struct Iterator: IteratorProtocol {
@@ -664,6 +680,13 @@ public struct TokenSequence: Sequence {
   }
 }
 
+extension TokenSequence: CustomReflectable {
+  public var customMirror: Mirror {
+    let keyAndValues = enumerated().map { (label: String($0.0) as String?, value: $0.1 as Any) }
+    return Mirror(self, children: keyAndValues)
+  }
+}
+
 /// Reverse sequence of tokens that are part of the provided Syntax node.
 public struct ReversedTokenSequence: Sequence {
   public struct Iterator: IteratorProtocol {
@@ -704,3 +727,11 @@ public struct ReversedTokenSequence: Sequence {
     return TokenSequence(node)
   }
 }
+
+
+extension ReversedTokenSequence: CustomReflectable {
+  public var customMirror: Mirror {
+    let keyAndValues = enumerated().map { (label: String($0.0) as String?, value: $0.1 as Any) }
+    return Mirror(self, children: keyAndValues)
+  }
+}

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -223,6 +223,16 @@ extension ${node.name}: Sequence {
     }
   }
 }
+%   end
+% end
 
+% for node in SYNTAX_NODES:
+%   if node.is_syntax_collection():
+extension ${node.name}: CustomReflectable {
+  public var customMirror: Mirror {
+    let keyAndValues = enumerated().map { (label: String($0.0) as String?, value: $0.1 as Any) }
+    return Mirror(self, children: keyAndValues)
+  }
+}
 %   end
 % end

Sources/SwiftSyntax/SyntaxNodes.swift.gyb

@@ -58,6 +58,12 @@ public struct UnknownSyntax: _SyntaxBase, Hashable {
   }
 }
 
+extension UnknownSyntax: CustomReflectable {
+  public var customMirror: Mirror {
+    return Mirror(self, children: [:])
+  }
+}
+
 % for node in SYNTAX_NODES:
 %   base_type = node.base_type
 %   if node.is_base():
@@ -169,7 +175,20 @@ public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
     return data.nodeId.hash(into: &hasher)
   }
 }
+%   end
+% end
 
+% for node in SYNTAX_NODES:
+%   if not node.is_base() and not node.is_syntax_collection():
+extension ${node.name}: CustomReflectable {
+  public var customMirror: Mirror {
+    return Mirror(self, children: [
+%     for child in node.children:
+      "${child.swift_name}": ${child.swift_name} as Any,
+%     end
+    ])
+  }
+}
 %   end
 % end
 

Sources/SwiftSyntax/Trivia.swift.gyb

@@ -62,6 +62,13 @@ extension TriviaPiece: TextOutputStreamable {
   }
 }
 
+extension TriviaPiece: CustomDebugStringConvertible {
+  /// Returns a description used by dump.
+  public var debugDescription: String {
+    return "TriviaPiece"
+  }
+}
+
 /// A collection of leading or trailing trivia. This is the main data structure
 /// for thinking about trivia.
 public struct Trivia {

Tests/LinuxMain.swift

@@ -16,6 +16,7 @@ XCTMain({ () -> [XCTestCaseEntry] in
     testCase(TokenSyntaxTestCase.allTests),
     testCase(SyntaxTreeModifierTests.allTests),
     testCase(TriviaTests.allTests),
+    testCase(CustomRelectableTests.allTests),
   ]
   return testCases
 }())

Tests/SwiftSyntaxTest/CustomReflecatbleTests.swift

@@ -0,0 +1,52 @@
+import XCTest
+import SwiftSyntax
+
+
+public class CustomReflectableTests: XCTestCase {
+    public static let allTests = [
+        ("testConformanceToCustomReflectable", testConformanceToCustomReflectable),
+    ]
+
+
+    public func testConformanceToCustomReflectable() {
+        XCTAssertNoThrow(try {
+            let parsed = try SyntaxParser.parse(getInput("near-empty.swift"))
+            XCTAssertEqual(collectSyntaxNotConformedCustomReflectable(from: parsed), [])
+        }())
+        XCTAssertNoThrow(try {
+            let parsed = try SyntaxParser.parse(getInput("closure.swift"))
+            XCTAssertEqual(collectSyntaxNotConformedCustomReflectable(from: parsed), [])
+        }())
+        XCTAssertNoThrow(try {
+            let parsed = try SyntaxParser.parse(getInput("nested-blocks.swift"))
+            XCTAssertEqual(collectSyntaxNotConformedCustomReflectable(from: parsed), [])
+        }())
+        XCTAssertNoThrow(try {
+            let parsed = try SyntaxParser.parse(getInput("visitor.swift"))
+            XCTAssertEqual(collectSyntaxNotConformedCustomReflectable(from: parsed), [])
+        }())
+    }
+
+
+    public func collectSyntaxNotConformedCustomReflectable<S: Any>(from object: S) -> [String] {
+        var paths = [String]()
+        collectSyntaxNotConformedCustomReflectable(from: object, ancestors: ["root"], foundPaths: &paths)
+        return paths
+    }
+
+
+    public func collectSyntaxNotConformedCustomReflectable<S: Any>(from object: S, ancestors: [String], foundPaths: inout [String]) {
+        Mirror(reflecting: object).children.forEach { child in
+            let (label: label, value: value) = child
+
+            var currentPathComponents = ancestors
+            currentPathComponents.append(label ?? "(nil)")
+
+            if let syntax = value as? Syntax, !(syntax is CustomReflectable) {
+                foundPaths.append("\(currentPathComponents.joined(separator: ".")): \(type(of: value as Any))")
+            }
+
+            collectSyntaxNotConformedCustomReflectable(from: value, ancestors: currentPathComponents, foundPaths: &foundPaths)
+        }
+    }
+}