rubydex 0.1.0.beta1-x86_64-linux → 0.1.0.beta2-x86_64-linux

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

@@ -0,0 +1,90 @@
+//! This module contains stable ID representations that compose the `Graph` global representation
+
+use std::{
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    ops::Deref,
+};
+use xxhash_rust::xxh3::xxh3_64;
+
+/// A stable ID representation using i64.
+///
+/// We use i64 instead of u64 because `SQLite` doesn't support unsigned integers.
+/// IDs are generated from `xxh3_64` hashes (u64) then cast to i64, preserving all bits.
+/// Negative values are expected and normal - not a sign of memory corruption.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Id<T> {
+    value: i64,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Id<T> {
+    #[must_use]
+    pub fn new(value: i64) -> Self {
+        Self {
+            value,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Deref for Id<T> {
+    type Target = i64;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+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> Hash for Id<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_i64(self.value);
+    }
+}
+
+impl<T> From<&str> for Id<T> {
+    fn from(value: &str) -> Self {
+        let hash = xxh3_64(value.as_bytes());
+        Self::new(hash.cast_signed())
+    }
+}
+
+impl<T> From<&String> for Id<T> {
+    fn from(value: &String) -> Self {
+        let hash = xxh3_64(value.as_bytes());
+        Self::new(hash.cast_signed())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(PartialEq, Eq, 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 deref_unwraps_value() {
+        let id = TestId::new(123);
+        assert_eq!(*id, 123);
+    }
+}

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

@@ -0,0 +1,54 @@
+//! 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_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

@@ -0,0 +1,32 @@
+use crate::model::id::Id;
+
+#[derive(PartialEq, Eq, 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, Debug, Clone, Copy)]
+pub struct DefinitionMarker;
+// DefinitionId represents the ID of a definition found in a specific file
+pub type DefinitionId = Id<DefinitionMarker>;
+
+#[derive(PartialEq, Eq, 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>;
+
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+pub struct StringMarker;
+/// `StringId` represents an ID for an interned string value
+pub type StringId = Id<StringMarker>;
+
+#[derive(PartialEq, Eq, 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>;
+
+#[derive(PartialEq, Eq, 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>;

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

@@ -0,0 +1,188 @@
+use crate::model::ids::{DeclarationId, NameId, StringId};
+
+#[derive(Debug, Clone)]
+pub struct Name {
+    /// The unqualified name of the constant
+    str: StringId,
+    /// The ID of parent scope for this constant. For example:
+    ///
+    /// ```ruby
+    /// Foo::Bar::Baz
+    /// # ^ parent scope of Bar::Baz
+    /// #      ^ parent scope of Baz
+    /// ```
+    ///
+    /// `None` indicates that this is a simple constant read or a top level reference
+    parent_scope: Option<NameId>,
+    /// The ID of the name for the nesting where we found this name. This effectively turns the structure into a linked
+    /// list of names to represent the nesting
+    nesting: Option<NameId>,
+    ref_count: usize,
+}
+
+impl Name {
+    #[must_use]
+    pub fn new(str: StringId, parent_scope: Option<NameId>, nesting: Option<NameId>) -> Self {
+        Self {
+            str,
+            parent_scope,
+            nesting,
+            ref_count: 1,
+        }
+    }
+
+    #[must_use]
+    pub fn str(&self) -> &StringId {
+        &self.str
+    }
+
+    #[must_use]
+    pub fn parent_scope(&self) -> &Option<NameId> {
+        &self.parent_scope
+    }
+
+    #[must_use]
+    pub fn nesting(&self) -> &Option<NameId> {
+        &self.nesting
+    }
+
+    #[must_use]
+    pub fn id(&self) -> NameId {
+        NameId::from(&format!(
+            "{}{}{}",
+            self.str,
+            self.parent_scope.map_or(String::from("None"), |id| id.to_string()),
+            self.nesting.map_or(String::from("None"), |id| id.to_string())
+        ))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ResolvedName {
+    name: Name,
+    declaration_id: DeclarationId,
+}
+
+impl ResolvedName {
+    #[must_use]
+    pub fn new(name: Name, declaration_id: DeclarationId) -> Self {
+        Self { name, declaration_id }
+    }
+
+    #[must_use]
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+
+    #[must_use]
+    pub fn declaration_id(&self) -> &DeclarationId {
+        &self.declaration_id
+    }
+}
+
+/// A usage of a constant name. This could be a constant reference or a definition like a class or module
+#[derive(Debug, Clone)]
+pub enum NameRef {
+    /// This name has not yet been resolved. We don't yet know what this name refers to or if it refers to an existing
+    /// declaration
+    Unresolved(Box<Name>),
+    /// This name has been resolved to an existing declaration
+    Resolved(Box<ResolvedName>),
+}
+
+impl NameRef {
+    #[must_use]
+    pub fn str(&self) -> &StringId {
+        match self {
+            NameRef::Unresolved(name) => name.str(),
+            NameRef::Resolved(resolved_name) => resolved_name.name.str(),
+        }
+    }
+
+    #[must_use]
+    pub fn parent_scope(&self) -> &Option<NameId> {
+        match self {
+            NameRef::Unresolved(name) => name.parent_scope(),
+            NameRef::Resolved(resolved_name) => resolved_name.name.parent_scope(),
+        }
+    }
+
+    #[must_use]
+    pub fn into_unresolved(self) -> Option<Name> {
+        match self {
+            NameRef::Unresolved(name) => Some(*name),
+            NameRef::Resolved(_) => None,
+        }
+    }
+
+    #[must_use]
+    pub fn nesting(&self) -> &Option<NameId> {
+        match self {
+            NameRef::Unresolved(name) => name.nesting(),
+            NameRef::Resolved(resolved_name) => resolved_name.name.nesting(),
+        }
+    }
+
+    #[must_use]
+    pub fn ref_count(&self) -> usize {
+        match self {
+            NameRef::Unresolved(name) => name.ref_count,
+            NameRef::Resolved(resolved_name) => resolved_name.name.ref_count,
+        }
+    }
+
+    pub fn increment_ref_count(&mut self, count: usize) {
+        match self {
+            NameRef::Unresolved(name) => name.ref_count += count,
+            NameRef::Resolved(resolved_name) => resolved_name.name.ref_count += count,
+        }
+    }
+
+    #[must_use]
+    pub fn decrement_ref_count(&mut self) -> bool {
+        match self {
+            NameRef::Unresolved(name) => {
+                name.ref_count -= 1;
+                name.ref_count > 0
+            }
+            NameRef::Resolved(resolved_name) => {
+                resolved_name.name.ref_count -= 1;
+                resolved_name.name.ref_count > 0
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn same_parent_scope_and_nesting() {
+        let name_1 = Name::new(StringId::from("Foo"), None, None);
+        let name_2 = Name::new(StringId::from("Foo"), None, None);
+        assert_eq!(name_1.id(), name_2.id());
+
+        let name_3 = Name::new(StringId::from("Foo"), Some(name_1.id()), None);
+        let name_4 = Name::new(StringId::from("Foo"), Some(name_2.id()), None);
+        assert_eq!(name_3.id(), name_4.id());
+
+        let name_5 = Name::new(StringId::from("Foo"), None, Some(name_1.id()));
+        let name_6 = Name::new(StringId::from("Foo"), None, Some(name_2.id()));
+        assert_eq!(name_5.id(), name_6.id());
+        assert_ne!(name_3.id(), name_5.id());
+        assert_ne!(name_4.id(), name_6.id());
+
+        let name_7 = Name::new(
+            StringId::from("Foo"),
+            Some(Name::new(StringId::from("Foo"), None, None).id()),
+            Some(Name::new(StringId::from("Foo"), None, None).id()),
+        );
+        let name_8 = Name::new(
+            StringId::from("Foo"),
+            Some(Name::new(StringId::from("Foo"), None, None).id()),
+            Some(Name::new(StringId::from("Foo"), None, None).id()),
+        );
+        assert_eq!(name_7.id(), name_8.id());
+    }
+}

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

@@ -0,0 +1,129 @@
+use crate::{
+    diagnostic::Diagnostic,
+    model::ids::{NameId, ReferenceId, StringId, UriId},
+    offset::Offset,
+};
+
+/// A reference to a constant
+#[derive(Debug)]
+pub struct ConstantReference {
+    /// The name ID of this reference
+    name_id: NameId,
+    /// The document where we found the reference
+    uri_id: UriId,
+    /// The offsets inside of the document where we found the reference
+    offset: Offset,
+    /// Diagnostics associated with this reference
+    diagnostics: Vec<Diagnostic>,
+}
+
+impl ConstantReference {
+    #[must_use]
+    pub fn new(name_id: NameId, uri_id: UriId, offset: Offset) -> Self {
+        Self {
+            name_id,
+            uri_id,
+            offset,
+            diagnostics: Vec::new(),
+        }
+    }
+
+    #[must_use]
+    pub fn name_id(&self) -> &NameId {
+        &self.name_id
+    }
+
+    #[must_use]
+    pub fn uri_id(&self) -> UriId {
+        self.uri_id
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn id(&self) -> ReferenceId {
+        // C:<uri_id>:<start>-<end>
+        let key = format!(
+            "C:{}:{}:{}-{}",
+            self.name_id,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        );
+        ReferenceId::from(&key)
+    }
+
+    #[must_use]
+    pub fn diagnostics(&self) -> &[Diagnostic] {
+        &self.diagnostics
+    }
+
+    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
+        self.diagnostics.push(diagnostic);
+    }
+}
+
+/// A reference to a method
+#[derive(Debug)]
+pub struct MethodRef {
+    /// The unqualified name of the method
+    str: StringId,
+    /// The document where we found the reference
+    uri_id: UriId,
+    /// The offsets inside of the document where we found the reference
+    offset: Offset,
+    /// Diagnostics associated with this reference
+    diagnostics: Vec<Diagnostic>,
+}
+
+impl MethodRef {
+    #[must_use]
+    pub fn new(str: StringId, uri_id: UriId, offset: Offset) -> Self {
+        Self {
+            str,
+            uri_id,
+            offset,
+            diagnostics: Vec::new(),
+        }
+    }
+
+    #[must_use]
+    pub fn str(&self) -> &StringId {
+        &self.str
+    }
+
+    #[must_use]
+    pub fn uri_id(&self) -> UriId {
+        self.uri_id
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn id(&self) -> ReferenceId {
+        // M:<uri_id>:<start>-<end>
+        let key = format!(
+            "M:{}:{}:{}-{}",
+            self.str,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        );
+        ReferenceId::from(&key)
+    }
+
+    #[must_use]
+    pub fn diagnostics(&self) -> &[Diagnostic] {
+        &self.diagnostics
+    }
+
+    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
+        self.diagnostics.push(diagnostic);
+    }
+}

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

@@ -0,0 +1,44 @@
+use std::ops::Deref;
+
+/// A reference-counted string used in the graph.
+///
+/// This struct wraps a `String` with a reference count to track how many times
+/// the string is used across the graph. When a document is removed, we decrement
+/// the reference count for each string it uses, and remove the string from the
+/// graph when its count reaches zero.
+#[derive(Debug)]
+pub struct StringRef {
+    value: String,
+    ref_count: usize,
+}
+
+impl StringRef {
+    #[must_use]
+    pub fn new(value: String) -> Self {
+        Self { value, ref_count: 1 }
+    }
+
+    #[must_use]
+    pub fn ref_count(&self) -> usize {
+        self.ref_count
+    }
+
+    pub fn increment_ref_count(&mut self, count: usize) {
+        self.ref_count += count;
+    }
+
+    #[must_use]
+    pub fn decrement_ref_count(&mut self) -> bool {
+        debug_assert!(self.ref_count > 0);
+        self.ref_count -= 1;
+        self.ref_count > 0
+    }
+}
+
+impl Deref for StringRef {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}

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

@@ -0,0 +1,41 @@
+use core::fmt;
+use std::fmt::Display;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Visibility {
+    Public,
+    Protected,
+    Private,
+    ModuleFunction,
+}
+
+impl Visibility {
+    /// Parse a visibility from a string.
+    ///
+    /// Valid values are `public`, `protected`, and `private`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the string is not a valid visibility
+    #[must_use]
+    pub fn from_string(str: &str) -> Self {
+        match str {
+            "public" => Self::Public,
+            "protected" => Self::Protected,
+            "private" => Self::Private,
+            "module_function" => Self::ModuleFunction,
+            _ => panic!("Invalid visibility: {str}"),
+        }
+    }
+}
+
+impl Display for Visibility {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Public => write!(f, "public"),
+            Self::Protected => write!(f, "protected"),
+            Self::Private => write!(f, "private"),
+            Self::ModuleFunction => write!(f, "module_function"),
+        }
+    }
+}

data/rust/rubydex/src/model.rs

@@ -0,0 +1,13 @@
+pub mod comment;
+pub mod declaration;
+pub mod definitions;
+pub mod document;
+pub mod encoding;
+pub mod graph;
+pub mod id;
+pub mod identity_maps;
+pub mod ids;
+pub mod name;
+pub mod references;
+pub mod string_ref;
+pub mod visibility;

data/rust/rubydex/src/offset.rs

@@ -0,0 +1,70 @@
+//! Offset handling for byte-based file positions.
+//!
+//! This module provides the [`Offset`] struct which represents a span of bytes
+//! within a file. It can be used to track positions in source code and convert
+//! between byte offsets and line/column positions.
+
+#[cfg(any(test, feature = "test_utils"))]
+use crate::model::document::Document;
+
+/// Represents a byte offset range within a specific file.
+///
+/// An `Offset` tracks a contiguous span of bytes from `start` to `end` within a file. This is useful for
+/// representing the location of tokens, AST nodes, or other text spans in source code.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct Offset {
+    /// The starting byte offset (inclusive)
+    start: u32,
+    /// The ending byte offset (exclusive)
+    end: u32,
+}
+
+impl Offset {
+    /// Creates a new `Offset` with the specified file ID and byte range.
+    ///
+    /// # Arguments
+    ///
+    /// * `start` - The starting byte position (inclusive)
+    /// * `end` - The ending byte position (exclusive)
+    #[must_use]
+    pub const fn new(start: u32, end: u32) -> Self {
+        Self { start, end }
+    }
+
+    /// # Panics
+    ///
+    /// This function can panic if the Prism location offsets do not fit into a u32
+    #[must_use]
+    pub fn from_prism_location(location: &ruby_prism::Location) -> Self {
+        Self::new(
+            location
+                .start_offset()
+                .try_into()
+                .expect("Expected usize `start` to fit in `u32`"),
+            location
+                .end_offset()
+                .try_into()
+                .expect("Expected usize `end` to fit in `u32`"),
+        )
+    }
+
+    #[must_use]
+    pub fn start(&self) -> u32 {
+        self.start
+    }
+
+    #[must_use]
+    pub fn end(&self) -> u32 {
+        self.end
+    }
+
+    /// Converts an offset to a display range like `1:1-1:5`
+    #[cfg(any(test, feature = "test_utils"))]
+    #[must_use]
+    pub fn to_display_range(&self, document: &Document) -> String {
+        let line_index = document.line_index();
+        let start = line_index.line_col(self.start().into());
+        let end = line_index.line_col(self.end().into());
+        format!("{}:{}-{}:{}", start.line + 1, start.col + 1, end.line + 1, end.col + 1)
+    }
+}

data/rust/rubydex/src/position.rs

@@ -0,0 +1,6 @@
+use line_index::LineCol;
+
+/// A position composed of line and columns. Note that all values are zero indexed and columns are based on the LSP
+/// specification, meaning that they are always based in code units and can be retrieved for the 3 supported encodings
+/// (Utf8, Utf16, Utf32)
+pub type Position = LineCol;