rubydex 0.1.0.beta11 → 0.1.0.beta13

data/rust/rubydex/src/model/id.rs

@@ -1,110 +1,110 @@
-use std::{marker::PhantomData, num::NonZeroU64, ops::Deref};
-use xxhash_rust::xxh3;
-
-/// Maps a u64 hash to a `NonZeroU64` by replacing 0 with `u64::MAX`.
-/// The probability of a 64-bit hash being exactly 0 is 2^-64 (~5.4e-20),
-/// and remapping 0 → MAX just means those two inputs collide — the same
-/// risk as any other hash collision, which the system already handles.
-const MAX_NONZERO: NonZeroU64 = NonZeroU64::new(u64::MAX).unwrap();
-
-#[inline]
-fn to_non_zero(value: u64) -> NonZeroU64 {
-    NonZeroU64::new(value).unwrap_or(MAX_NONZERO)
-}
-
-/// A deterministic type-safe ID representation.
-///
-/// Uses `NonZeroU64` internally so that `Option<Id<T>>` is 8 bytes (same as `Id<T>`)
-/// via niche optimization, instead of 16 bytes with a plain `u64`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Id<T> {
-    value: NonZeroU64,
-    _marker: PhantomData<T>,
-}
-
-impl<T> Id<T> {
-    #[must_use]
-    pub fn new(value: u64) -> Self {
-        Self {
-            value: to_non_zero(value),
-            _marker: PhantomData,
-        }
-    }
-
-    /// Returns the underlying `u64` value.
-    #[must_use]
-    pub fn get(&self) -> u64 {
-        self.value.get()
-    }
-}
-
-impl<T> Deref for Id<T> {
-    type Target = u64;
-
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: NonZeroU64 is #[repr(transparent)] over u64.
-        // Deref requires returning &u64, but NonZeroU64::get() returns by value,
-        // so the pointer cast is unavoidable here. Prefer Id::get() when a u64
-        // value (not a reference) is sufficient.
-        unsafe { &*std::ptr::from_ref(&self.value).cast::<u64>() }
-    }
-}
-
-impl<T> std::fmt::Display for Id<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.value)
-    }
-}
-
-impl<T> From<&str> for Id<T> {
-    fn from(value: &str) -> Self {
-        let hash = xxh3::xxh3_64(value.as_bytes());
-        Self::new(hash)
-    }
-}
-
-impl<T> From<&String> for Id<T> {
-    fn from(value: &String) -> Self {
-        let hash = xxh3::xxh3_64(value.as_bytes());
-        Self::new(hash)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-    pub struct Marker;
-    pub type TestId = Id<Marker>;
-
-    #[test]
-    fn test_create_hash() {
-        // Same input should produce same hash (deterministic)
-        let id1 = TestId::from("test_input");
-        let id2 = TestId::from("test_input");
-        assert_eq!(id1, id2);
-
-        // Different inputs should produce different hashes (unique)
-        let id3 = TestId::from("different_input");
-        assert_ne!(id1, id3);
-    }
-
-    #[test]
-    fn get_returns_value() {
-        let id = TestId::new(123);
-        assert_eq!(id.get(), 123);
-    }
-
-    #[test]
-    fn optional_id_is_still_8_bytes() {
-        assert_eq!(std::mem::size_of::<Option<TestId>>(), 8);
-        assert_eq!(std::mem::size_of::<TestId>(), 8);
-    }
-
-    #[test]
-    fn zero_hash_maps_to_nonzero() {
-        let id = TestId::new(0);
-        assert_eq!(id.get(), u64::MAX);
-    }
-}
+use std::{marker::PhantomData, num::NonZeroU64, ops::Deref};
+use xxhash_rust::xxh3;
+
+/// Maps a u64 hash to a `NonZeroU64` by replacing 0 with `u64::MAX`.
+/// The probability of a 64-bit hash being exactly 0 is 2^-64 (~5.4e-20),
+/// and remapping 0 → MAX just means those two inputs collide — the same
+/// risk as any other hash collision, which the system already handles.
+const MAX_NONZERO: NonZeroU64 = NonZeroU64::new(u64::MAX).unwrap();
+
+#[inline]
+fn to_non_zero(value: u64) -> NonZeroU64 {
+    NonZeroU64::new(value).unwrap_or(MAX_NONZERO)
+}
+
+/// A deterministic type-safe ID representation.
+///
+/// Uses `NonZeroU64` internally so that `Option<Id<T>>` is 8 bytes (same as `Id<T>`)
+/// via niche optimization, instead of 16 bytes with a plain `u64`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Id<T> {
+    value: NonZeroU64,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Id<T> {
+    #[must_use]
+    pub fn new(value: u64) -> Self {
+        Self {
+            value: to_non_zero(value),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the underlying `u64` value.
+    #[must_use]
+    pub fn get(&self) -> u64 {
+        self.value.get()
+    }
+}
+
+impl<T> Deref for Id<T> {
+    type Target = u64;
+
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: NonZeroU64 is #[repr(transparent)] over u64.
+        // Deref requires returning &u64, but NonZeroU64::get() returns by value,
+        // so the pointer cast is unavoidable here. Prefer Id::get() when a u64
+        // value (not a reference) is sufficient.
+        unsafe { &*std::ptr::from_ref(&self.value).cast::<u64>() }
+    }
+}
+
+impl<T> std::fmt::Display for Id<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.value)
+    }
+}
+
+impl<T> From<&str> for Id<T> {
+    fn from(value: &str) -> Self {
+        let hash = xxh3::xxh3_64(value.as_bytes());
+        Self::new(hash)
+    }
+}
+
+impl<T> From<&String> for Id<T> {
+    fn from(value: &String) -> Self {
+        let hash = xxh3::xxh3_64(value.as_bytes());
+        Self::new(hash)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+    pub struct Marker;
+    pub type TestId = Id<Marker>;
+
+    #[test]
+    fn test_create_hash() {
+        // Same input should produce same hash (deterministic)
+        let id1 = TestId::from("test_input");
+        let id2 = TestId::from("test_input");
+        assert_eq!(id1, id2);
+
+        // Different inputs should produce different hashes (unique)
+        let id3 = TestId::from("different_input");
+        assert_ne!(id1, id3);
+    }
+
+    #[test]
+    fn get_returns_value() {
+        let id = TestId::new(123);
+        assert_eq!(id.get(), 123);
+    }
+
+    #[test]
+    fn optional_id_is_still_8_bytes() {
+        assert_eq!(std::mem::size_of::<Option<TestId>>(), 8);
+        assert_eq!(std::mem::size_of::<TestId>(), 8);
+    }
+
+    #[test]
+    fn zero_hash_maps_to_nonzero() {
+        let id = TestId::new(0);
+        assert_eq!(id.get(), u64::MAX);
+    }
+}

data/rust/rubydex/src/model/identity_maps.rs

@@ -1,58 +1,58 @@
-//! This module contains identity maps that use externally hashed IDs as keys. They are used to avoid hashing the same
-//! value twice, simply using the given key directly
-
-use std::{
-    collections::{HashMap, HashSet},
-    hash::{BuildHasher, Hasher},
-};
-
-#[derive(Default)]
-pub struct IdentityHasher {
-    hash: u64,
-}
-
-impl Hasher for IdentityHasher {
-    fn write(&mut self, _bytes: &[u8]) {
-        unreachable!("IdentityHasher only supports write_u64");
-    }
-
-    fn write_u32(&mut self, i: u32) {
-        self.hash = u64::from(i);
-    }
-
-    fn write_u64(&mut self, i: u64) {
-        self.hash = i;
-    }
-
-    fn finish(&self) -> u64 {
-        self.hash
-    }
-}
-
-#[derive(Default)]
-pub struct IdentityHashBuilder;
-
-impl BuildHasher for IdentityHashBuilder {
-    type Hasher = IdentityHasher;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        IdentityHasher::default()
-    }
-}
-
-pub type IdentityHashMap<K, V> = HashMap<K, V, IdentityHashBuilder>;
-pub type IdentityHashSet<T> = HashSet<T, IdentityHashBuilder>;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn identity_hasher_uses_value_as_is() {
-        let builder = IdentityHashBuilder;
-        let mut hasher = builder.build_hasher();
-
-        hasher.write_u64(42);
-        assert_eq!(hasher.finish(), 42);
-    }
-}
+//! This module contains identity maps that use externally hashed IDs as keys. They are used to avoid hashing the same
+//! value twice, simply using the given key directly
+
+use std::{
+    collections::{HashMap, HashSet},
+    hash::{BuildHasher, Hasher},
+};
+
+#[derive(Default)]
+pub struct IdentityHasher {
+    hash: u64,
+}
+
+impl Hasher for IdentityHasher {
+    fn write(&mut self, _bytes: &[u8]) {
+        unreachable!("IdentityHasher only supports write_u64");
+    }
+
+    fn write_u32(&mut self, i: u32) {
+        self.hash = u64::from(i);
+    }
+
+    fn write_u64(&mut self, i: u64) {
+        self.hash = i;
+    }
+
+    fn finish(&self) -> u64 {
+        self.hash
+    }
+}
+
+#[derive(Default)]
+pub struct IdentityHashBuilder;
+
+impl BuildHasher for IdentityHashBuilder {
+    type Hasher = IdentityHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        IdentityHasher::default()
+    }
+}
+
+pub type IdentityHashMap<K, V> = HashMap<K, V, IdentityHashBuilder>;
+pub type IdentityHashSet<T> = HashSet<T, IdentityHashBuilder>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn identity_hasher_uses_value_as_is() {
+        let builder = IdentityHashBuilder;
+        let mut hasher = builder.build_hasher();
+
+        hasher.write_u64(42);
+        assert_eq!(hasher.finish(), 42);
+    }
+}

data/rust/rubydex/src/model/ids.rs

@@ -1,38 +1,60 @@
-use crate::{assert_mem_size, model::id::Id};
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct DeclarationMarker;
-/// `DeclarationId` represents the ID of a fully qualified name. For example, `Foo::Bar` or `Foo#my_method`
-pub type DeclarationId = Id<DeclarationMarker>;
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct DefinitionMarker;
-
-// DefinitionId represents the ID of a definition found in a specific file
-pub type DefinitionId = Id<DefinitionMarker>;
-assert_mem_size!(DefinitionId, 8);
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct UriMarker;
-// UriId represents the ID of a URI, which is the unique identifier for a document
-pub type UriId = Id<UriMarker>;
-assert_mem_size!(UriId, 8);
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct StringMarker;
-/// `StringId` represents an ID for an interned string value
-pub type StringId = Id<StringMarker>;
-assert_mem_size!(StringId, 8);
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct ReferenceMarker;
-/// `ReferenceId` represents the ID of a reference occurrence in a file.
-/// It is built from the reference kind, `uri_id` and the reference `offset`.
-pub type ReferenceId = Id<ReferenceMarker>;
-assert_mem_size!(ReferenceId, 8);
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-pub struct NameMarker;
-/// `NameId` represents an ID for any constant name that we find as part of a reference or definition
-pub type NameId = Id<NameMarker>;
-assert_mem_size!(NameId, 8);
+use crate::{assert_mem_size, model::id::Id};
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct DeclarationMarker;
+/// `DeclarationId` represents the ID of a fully qualified name. For example, `Foo::Bar` or `Foo#my_method`
+pub type DeclarationId = Id<DeclarationMarker>;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct DefinitionMarker;
+
+// DefinitionId represents the ID of a definition found in a specific file
+pub type DefinitionId = Id<DefinitionMarker>;
+assert_mem_size!(DefinitionId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct UriMarker;
+// UriId represents the ID of a URI, which is the unique identifier for a document
+pub type UriId = Id<UriMarker>;
+assert_mem_size!(UriId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct StringMarker;
+/// `StringId` represents an ID for an interned string value
+pub type StringId = Id<StringMarker>;
+assert_mem_size!(StringId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct NameMarker;
+/// `NameId` represents an ID for any constant name that we find as part of a reference or definition
+pub type NameId = Id<NameMarker>;
+assert_mem_size!(NameId, 8);
+
+// Reference IDs
+//
+// This section is for specialized IDs for each type of declaration reference
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct ConstantMarker;
+pub type ConstantReferenceId = Id<ConstantMarker>;
+assert_mem_size!(ConstantReferenceId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct MethodMarker;
+pub type MethodReferenceId = Id<MethodMarker>;
+assert_mem_size!(MethodReferenceId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct GlobalVariableMarker;
+pub type GlobalVariableReferenceId = Id<GlobalVariableMarker>;
+assert_mem_size!(GlobalVariableReferenceId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct ClassVariableMarker;
+pub type ClassVariableReferenceId = Id<ClassVariableMarker>;
+assert_mem_size!(ClassVariableReferenceId, 8);
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+pub struct InstanceVariableMarker;
+pub type InstanceVariableReferenceId = Id<InstanceVariableMarker>;
+assert_mem_size!(InstanceVariableReferenceId, 8);