Factor out the Hashable conformance for syntax nodes to separate protocol

This allows us to use SyntaxProtocol as a return value again and provide
nice functions that check if type-erased note conforms to a protocol.

Author: ahoppen

Sources/SwiftSyntax/Syntax.swift

@@ -1,4 +1,4 @@
-//===-------------------- Syntax.swift - Syntax Protocol ------------------===//
+//===--------------- Syntax.swift - Base Syntax Type eraser  --------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -13,7 +13,7 @@
 /// A Syntax node represents a tree of nodes with tokens at the leaves.
 /// Each node has accessors for its known children, and allows efficient
 /// iteration over the children through its `children` property.
-public struct Syntax: SyntaxProtocol {
+public struct Syntax: SyntaxProtocol, SyntaxHashable {
   let data: SyntaxData
 
   public var _syntaxNode: Syntax {
@@ -57,11 +57,26 @@ extension Syntax: CustomReflectable {
   }
 }
 
+/// Protocol that provides a common Hashable implementation for all syntax nodes
+public protocol SyntaxHashable: Hashable {
+  var _syntaxNode: Syntax { get }
+}
+
+public extension SyntaxHashable {
+  func hash(into hasher: inout Hasher) {
+    return _syntaxNode.data.nodeId.hash(into: &hasher)
+  }
+
+  static func ==(lhs: Self, rhs: Self) -> Bool {
+    return lhs._syntaxNode.data.nodeId == rhs._syntaxNode.data.nodeId
+  }
+}
+
 /// Provide common functionality for specialized syntax nodes. Extend this
 /// protocol to provide common functionality for all syntax nodes.
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol SyntaxProtocol: CustomStringConvertible,
-    CustomDebugStringConvertible, TextOutputStreamable, Hashable {
+    CustomDebugStringConvertible, TextOutputStreamable {
 
   /// Retrieve the generic syntax node that is represented by this node.
   /// Do not retrieve this property directly. Use `Syntax(self)` instead.
@@ -415,14 +430,6 @@ public extension SyntaxProtocol {
     where Target: TextOutputStream {
     data.raw.write(to: &target)
   }
-
-  func hash(into hasher: inout Hasher) {
-    return data.nodeId.hash(into: &hasher)
-  }
-
-  static func ==(lhs: Self, rhs: Self) -> Bool {
-    return lhs.data.nodeId == rhs.data.nodeId
-  }
 }
 
 /// Sequence of tokens that are part of the provided Syntax node.

Sources/SwiftSyntax/SyntaxBaseNodes.swift.gyb

@@ -32,7 +32,7 @@ public protocol ${node.name}Protocol: ${base_type}Protocol {}
 %     for line in dedented_lines(node.description):
 /// ${line}
 %     end
-public struct ${node.name}: ${node.name}Protocol {
+public struct ${node.name}: ${node.name}Protocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: ${node.name}Protocol>(_ syntax: S) {

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -31,7 +31,7 @@ public protocol SyntaxCollection: SyntaxProtocol, Sequence {
 /// `${node.collection_element_type}` nodes. ${node.name} behaves
 /// as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
-public struct ${node.name}: SyntaxCollection {
+public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   /// Converts the given `Syntax` node to a `${node.name}` if possible. Returns 

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -46,7 +46,7 @@ nodes whose base kind are that specified kind.
 %     for line in dedented_lines(node.description):
 /// ${line}
 %     end
-public struct ${node.name}: ${base_type}Protocol {
+public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
 %     # ======
 %     # Cursor
 %     # ======

Sources/SwiftSyntax/SyntaxOtherNodes.swift

@@ -15,7 +15,7 @@
 // MARK: UnknownSyntax
 
 /// A wrapper around a raw Syntax layout.
-public struct UnknownSyntax: SyntaxProtocol {
+public struct UnknownSyntax: SyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   /// Convert the given `Syntax` node to an `UnknownSyntax` if possible. Return
@@ -43,7 +43,7 @@ extension UnknownSyntax: CustomReflectable {
 // MARK: TokenSyntax
 
 /// A Syntax node representing a single token.
-public struct TokenSyntax: SyntaxProtocol {
+public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   /// Converts the given `Syntax` node to a `TokenSyntax` if possible. Returns

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -19,7 +19,7 @@
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol DeclSyntaxProtocol: SyntaxProtocol {}
 
-public struct DeclSyntax: DeclSyntaxProtocol {
+public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: DeclSyntaxProtocol>(_ syntax: S) {
@@ -81,7 +81,7 @@ extension DeclSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol ExprSyntaxProtocol: SyntaxProtocol {}
 
-public struct ExprSyntax: ExprSyntaxProtocol {
+public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: ExprSyntaxProtocol>(_ syntax: S) {
@@ -143,7 +143,7 @@ extension ExprSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol StmtSyntaxProtocol: SyntaxProtocol {}
 
-public struct StmtSyntax: StmtSyntaxProtocol {
+public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: StmtSyntaxProtocol>(_ syntax: S) {
@@ -205,7 +205,7 @@ extension StmtSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol TypeSyntaxProtocol: SyntaxProtocol {}
 
-public struct TypeSyntax: TypeSyntaxProtocol {
+public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: TypeSyntaxProtocol>(_ syntax: S) {
@@ -267,7 +267,7 @@ extension TypeSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol PatternSyntaxProtocol: SyntaxProtocol {}
 
-public struct PatternSyntax: PatternSyntaxProtocol {
+public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
   public init<S: PatternSyntaxProtocol>(_ syntax: S) {