[Experiment] Add Hashable conformance to concrete types

Author: harlanhaskins

test/SwiftSyntax/LazyCaching.swift

@@ -15,8 +15,7 @@ LazyCaching.test("Pathological") {
   let tuple = SyntaxFactory.makeVoidTupleType()
 
   DispatchQueue.concurrentPerform(iterations: 100) { _ in
-    expectEqual(tuple.leftParen.uniqueIdentifier, 
-                tuple.leftParen.uniqueIdentifier)
+    expectEqual(tuple.leftParen, tuple.leftParen)
   }
 }
 
@@ -42,9 +41,9 @@ LazyCaching.test("TwoAccesses") {
 
   expectNotNil(node1)
   expectNotNil(node2)
-  expectEqual(node1?.uniqueIdentifier, node2?.uniqueIdentifier)
-  expectEqual(node1?.uniqueIdentifier, final.uniqueIdentifier)
-  expectEqual(node2?.uniqueIdentifier, final.uniqueIdentifier)
+  expectEqual(node1, node2)
+  expectEqual(node1, final)
+  expectEqual(node2, final)
 }
 
 runAllTests()

test/SwiftSyntax/SyntaxFactory.swift

@@ -34,7 +34,7 @@ SyntaxFactoryAPI.test("Generated") {
               }
               """)
 
-  let forType = SyntaxFactory.makeIdentifier("for", 
+  let forType = SyntaxFactory.makeIdentifier("for",
                                              leadingTrivia: .backticks(1),
                                              trailingTrivia: [
                                                .backticks(1), .spaces(1)
@@ -52,19 +52,17 @@ SyntaxFactoryAPI.test("Generated") {
               }
               """)
 
-  expectNotEqual(structDecl.members.uniqueIdentifier, 
-                 renamed.members.uniqueIdentifier)
-  expectEqual(structDecl.uniqueIdentifier, structDecl.root.uniqueIdentifier)
+  expectNotEqual(structDecl.members, renamed.members)
+  expectEqual(structDecl, structDecl.root as? StructDeclSyntax)
   expectNil(structDecl.parent)
   expectNotNil(structDecl.members.parent)
-  expectEqual(structDecl.members.parent?.uniqueIdentifier, 
-              structDecl.uniqueIdentifier)
+  expectEqual(structDecl.members.parent as? StructDeclSyntax, structDecl)
 
   // Ensure that accessing children via named identifiers is exactly the
   // same as accessing them as their underlying data.
-  expectEqual(structDecl.members.uniqueIdentifier, 
-              structDecl.child(at: 7)?.uniqueIdentifier)
-  
+  expectEqual(structDecl.members,
+              structDecl.child(at: 7) as? MemberDeclBlockSyntax)
+
   expectEqual("\(structDecl.members.rightBrace)",
               """
 

test/SwiftSyntax/VisitorTest.swift

@@ -31,11 +31,11 @@ VisitorTests.test("Basic") {
   expectDoesNotThrow({
     let parsed = try Syntax.parse(getInput("visitor.swift"))
     let counter = FuncCounter()
-    let idBefore = parsed.uniqueIdentifier
+    let hashBefore = parsed.hashValue
     counter.visit(parsed)
     expectEqual(counter.funcCount, 3)
-    expectEqual(idBefore, parsed.uniqueIdentifier)
+    expectEqual(hashBefore, parsed.hashValue)
   })
 }
 
-runAllTests()
+runAllTests()

tools/SwiftSyntax/Syntax.swift

@@ -63,10 +63,6 @@ extension Syntax {
     return data.raw
   }
 
-  public var uniqueIdentifier: Int {
-    return ObjectIdentifier(data).hashValue
-  }
-
   /// An iterator over children of this node.
   public var children: SyntaxChildren {
     return SyntaxChildren(node: self)
@@ -158,13 +154,13 @@ extension Syntax {
 
 /// Determines if two nodes are equal to each other.
 public func ==(lhs: Syntax, rhs: Syntax) -> Bool {
-  return lhs.uniqueIdentifier == rhs.uniqueIdentifier
+  return lhs.data === rhs.data
 }
 
 /// MARK: - Nodes
 
 /// A Syntax node representing a single token.
-public struct TokenSyntax: _SyntaxBase {
+public struct TokenSyntax: _SyntaxBase, Hashable {
   var _root: SyntaxData
   unowned var _data: SyntaxData 
 
@@ -251,4 +247,12 @@ public struct TokenSyntax: _SyntaxBase {
     }
     return kind
   }
+
+  public static func ==(lhs: TokenSyntax, rhs: TokenSyntax) -> Bool {
+    return lhs._data === rhs._data
+  }
+
+  public var hashValue: Int {
+    return ObjectIdentifier(_data).hashValue
+  }
 }

tools/SwiftSyntax/SyntaxNodes.swift.gyb

@@ -38,7 +38,7 @@ Each node will have:
 """
 }%
 
-public struct AnySyntax: _SyntaxBase {
+public struct AnySyntax: _SyntaxBase, Hashable {
   var _root: SyntaxData
   unowned var _data: SyntaxData
 
@@ -47,27 +47,44 @@ public struct AnySyntax: _SyntaxBase {
     self._root = root
     self._data = data
   }
+  
+  public static func ==(lhs: AnySyntax, rhs: AnySyntax) -> Bool {
+    return lhs._data === rhs._data
+  }
+
+  public var hashValue: Int {
+    return ObjectIdentifier(_data).hashValue
+  }
 }
 
 % for node in SYNTAX_NODES:
 %   base_type = node.base_type
 %   if node.is_base():
 public protocol ${node.name}: Syntax {}
-public struct Any${node.name}: ${node.name}, _SyntaxBase {
+public struct ${node.swift_type_name}: ${node.name}, _SyntaxBase, Hashable {
   var _root: SyntaxData
   unowned var _data: SyntaxData
 
-  /// Creates an `Any${node.name}`` node from the provided root and data.
+  /// Creates an `${node.swift_type_name}` node from the provided root and data.
   internal init(root: SyntaxData, data: SyntaxData) {
     self._root = root
     self._data = data
   }
+
+  public static func ==(lhs: ${node.swift_type_name},
+                        rhs: ${node.swift_type_name}) -> Bool {
+    return lhs._data === rhs._data
+  }
+
+  public var hashValue: Int {
+    return ObjectIdentifier(_data).hashValue
+  }
 }
 
 %   elif node.collection_element:
 public typealias ${node.name} = SyntaxCollection<${node.swift_collection_element_type}>
 %   else:
-public struct ${node.name}: ${base_type}, _SyntaxBase {
+public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
 %     if node.children:
   enum Cursor: Int {
 %       for child in node.children:
@@ -157,6 +174,15 @@ public struct ${node.name}: ${base_type}, _SyntaxBase {
     return ${node.name}(root: root, data: newData)
   }
 %     end
+
+  public static func ==(lhs: ${node.swift_type_name},
+                        rhs: ${node.swift_type_name}) -> Bool {
+    return lhs._data === rhs._data
+  }
+
+  public var hashValue: Int {
+    return ObjectIdentifier(_data).hashValue
+  }
 }
 
 %   end