Remove StableHasher::finalize by inlining it's routine

Author: Urgau

CHANGELOG.md

@@ -1,3 +1,4 @@
 # Unreleased
 
+- Remove `StableHasher::finalize` (#4)
 - Import stable hasher implementation from rustc ([db8aca48129](https://github.com/rust-lang/rust/blob/db8aca48129d86b2623e3ac8cbcf2902d4d313ad/compiler/rustc_data_structures/src/))

src/stable_hasher.rs

@@ -10,7 +10,7 @@ mod tests;
 
 /// Trait for retrieving the result of the stable hashing operation.
 pub trait StableHasherResult: Sized {
-    fn finish(hasher: StableHasher) -> Self;
+    fn finish(hash: (u64, u64)) -> Self;
 }
 
 /// When hashing something that ends up affecting properties like symbol names,
@@ -40,12 +40,7 @@ impl StableHasher {
 
     #[inline]
     pub fn finish<W: StableHasherResult>(self) -> W {
-        W::finish(self)
-    }
-
-    #[inline]
-    pub fn finalize(self) -> (u64, u64) {
-        self.state.finish128()
+        W::finish(self.state.finish128())
     }
 }
 

src/stable_hasher/tests.rs

@@ -9,6 +9,15 @@ use super::*;
 // ways). The expected values depend on the hashing algorithm used, so they
 // need to be updated whenever StableHasher changes its hashing algorithm.
 
+#[derive(Debug, PartialEq)]
+struct TestHash((u64, u64));
+
+impl StableHasherResult for TestHash {
+    fn finish(hash: (u64, u64)) -> TestHash {
+        TestHash(hash)
+    }
+}
+
 #[test]
 fn test_hash_integers() {
     // Test that integers are handled consistently across platforms.
@@ -41,9 +50,9 @@ fn test_hash_integers() {
     test_isize.hash(&mut h);
 
     // This depends on the hashing algorithm. See note at top of file.
-    let expected = (13997337031081104755, 6178945012502239489);
+    let expected = TestHash((13997337031081104755, 6178945012502239489));
 
-    assert_eq!(h.finalize(), expected);
+    assert_eq!(expected, h.finish());
 }
 
 #[test]
@@ -55,9 +64,9 @@ fn test_hash_usize() {
     test_usize.hash(&mut h);
 
     // This depends on the hashing algorithm. See note at top of file.
-    let expected = (12037165114281468837, 3094087741167521712);
+    let expected = TestHash((12037165114281468837, 3094087741167521712));
 
-    assert_eq!(h.finalize(), expected);
+    assert_eq!(expected, h.finish());
 }
 
 #[test]
@@ -69,15 +78,15 @@ fn test_hash_isize() {
     test_isize.hash(&mut h);
 
     // This depends on the hashing algorithm. See note at top of file.
-    let expected = (3979067582695659080, 2322428596355037273);
+    let expected = TestHash((3979067582695659080, 2322428596355037273));
 
-    assert_eq!(h.finalize(), expected);
+    assert_eq!(expected, h.finish());
 }
 
-fn hash<T: Hash>(t: &T) -> (u64, u64) {
+fn hash<T: Hash>(t: &T) -> TestHash {
     let mut h = StableHasher::new();
     t.hash(&mut h);
-    h.finalize()
+    h.finish()
 }
 
 // Check that the `isize` hashing optimization does not produce the same hash when permuting two