Use consistent to/from naming convention in Fingerprint

Author: tgnottingham

compiler/rustc_ast/src/crate_disambiguator.rs

@@ -20,7 +20,7 @@ impl CrateDisambiguator {
 
 impl fmt::Display for CrateDisambiguator {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.write_str(&base_n::encode(self.0.as_value_u128(), base_n::CASE_INSENSITIVE))
+        f.write_str(&base_n::encode(self.0.to_value_u128(), base_n::CASE_INSENSITIVE))
     }
 }
 

compiler/rustc_data_structures/src/fingerprint.rs

@@ -46,7 +46,7 @@ impl Fingerprint {
     }
 
     #[inline]
-    pub fn as_value(&self) -> (u64, u64) {
+    pub fn to_value(&self) -> (u64, u64) {
         (
             ((self.0[0] as u64) << 0)
                 | ((self.0[1] as u64) << 8)
@@ -73,8 +73,8 @@ impl Fingerprint {
     }
 
     #[inline]
-    pub fn as_value_u128(&self) -> u128 {
-        let (v0, v1) = self.as_value();
+    pub fn to_value_u128(&self) -> u128 {
+        let (v0, v1) = self.to_value();
         v0 as u128 | ((v1 as u128) << 64)
     }
 
@@ -85,27 +85,27 @@ impl Fingerprint {
 
     #[inline]
     pub fn to_smaller_hash(&self) -> u64 {
-        self.as_value().0
+        self.to_value().0
     }
 
     #[inline]
     pub fn combine(self, other: Fingerprint) -> Fingerprint {
         // See https://stackoverflow.com/a/27952689 on why this function is
         // implemented this way.
-        let v = self.as_value_u128().wrapping_mul(3).wrapping_add(other.as_value_u128());
+        let v = self.to_value_u128().wrapping_mul(3).wrapping_add(other.to_value_u128());
         Fingerprint::from_value_u128(v)
     }
 
     // Combines two hashes in an order independent way. Make sure this is what
     // you want.
     #[inline]
     pub fn combine_commutative(self, other: Fingerprint) -> Fingerprint {
-        let v = self.as_value_u128().wrapping_add(other.as_value_u128());
+        let v = self.to_value_u128().wrapping_add(other.to_value_u128());
         Fingerprint::from_value_u128(v)
     }
 
     pub fn to_hex(&self) -> String {
-        let (self0, self1) = self.as_value();
+        let (self0, self1) = self.to_value();
         format!("{:x}{:x}", self0, self1)
     }
 
@@ -123,7 +123,7 @@ impl Fingerprint {
 
 impl std::fmt::Display for Fingerprint {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let (self0, self1) = self.as_value();
+        let (self0, self1) = self.to_value();
         write!(formatter, "{:x}-{:x}", self0, self1)
     }
 }
@@ -132,7 +132,7 @@ impl Ord for Fingerprint {
     #[inline]
     fn cmp(&self, other: &Fingerprint) -> Ordering {
         // This implementation is faster than the one generated by the `derive` attribute.
-        self.as_value_u128().cmp(&other.as_value_u128())
+        self.to_value_u128().cmp(&other.to_value_u128())
     }
 }
 
@@ -148,7 +148,7 @@ impl PartialEq for Fingerprint {
     #[inline]
     fn eq(&self, other: &Fingerprint) -> bool {
         // This implementation is faster than the one generated by the `derive` attribute.
-        self.as_value_u128() == other.as_value_u128()
+        self.to_value_u128() == other.to_value_u128()
     }
 }
 
@@ -167,7 +167,7 @@ impl<H: Hasher> FingerprintHasher for H {
     #[inline]
     default fn write_fingerprint(&mut self, fingerprint: &Fingerprint) {
         // It's faster to hash this as two `u64`s than as a `u128` or slice.
-        let (fingerprint0, fingerprint1) = fingerprint.as_value();
+        let (fingerprint0, fingerprint1) = fingerprint.to_value();
         self.write_u64(fingerprint0);
         self.write_u64(fingerprint1);
     }
@@ -177,7 +177,7 @@ impl FingerprintHasher for crate::unhash::Unhasher {
     #[inline]
     fn write_fingerprint(&mut self, fingerprint: &Fingerprint) {
         // `Unhasher` only wants a single `u64`
-        let (fingerprint0, _) = fingerprint.as_value();
+        let (fingerprint0, _) = fingerprint.to_value();
         self.write_u64(fingerprint0);
     }
 }

compiler/rustc_data_structures/src/fingerprint/tests.rs

@@ -3,15 +3,15 @@ use super::*;
 #[test]
 fn test_value_roundtrip() {
     let f0 = Fingerprint::from_value(0x00221133_44665577, 0x88AA99BB_CCEEDDFF);
-    let v = f0.as_value();
+    let v = f0.to_value();
     let f1 = Fingerprint::from_value(v.0, v.1);
     assert_eq!(f0, f1);
 }
 
 #[test]
 fn test_value_u128_roundtrip() {
     let f0 = Fingerprint::from_value_u128(0x00221133_44665577_88AA99BB_CCEEDDFF);
-    let v = f0.as_value_u128();
+    let v = f0.to_value_u128();
     let f1 = Fingerprint::from_value_u128(v);
     assert_eq!(f0, f1);
 }

compiler/rustc_save_analysis/src/dump_visitor.rs

@@ -147,7 +147,7 @@ impl<'tcx> DumpVisitor<'tcx> {
                     .sess
                     .local_crate_disambiguator()
                     .to_fingerprint()
-                    .as_value(),
+                    .to_value(),
             },
             crate_root: crate_root.unwrap_or_else(|| "<no source>".to_owned()),
             external_crates: self.save_ctxt.get_external_crates(),

compiler/rustc_save_analysis/src/lib.rs

@@ -128,7 +128,7 @@ impl<'tcx> SaveContext<'tcx> {
                 num: n.as_u32(),
                 id: GlobalCrateId {
                     name: self.tcx.crate_name(n).to_string(),
-                    disambiguator: self.tcx.crate_disambiguator(n).to_fingerprint().as_value(),
+                    disambiguator: self.tcx.crate_disambiguator(n).to_fingerprint().to_value(),
                 },
             });
         }