rubydex 0.1.0.beta12-aarch64-linux

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

@@ -0,0 +1,298 @@
+use std::fmt::Display;
+
+use crate::{
+    assert_mem_size,
+    model::ids::{DeclarationId, NameId, StringId},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ParentScope {
+    /// There's no parent scope in this reference (e.g.: `Foo`)
+    None,
+    /// There's an empty parent scope in this reference (e.g.: `::Foo`)
+    TopLevel,
+    /// There's a parent scope in this reference (e.g.: `Foo::Bar`)
+    Some(NameId),
+    /// Parent scope representing the class attached to a singleton class context
+    ///
+    ///  `Foo::<Foo>::<<Foo>>`
+    ///  ^ Attached for <Foo>
+    ///        ^ Attached for <<Foo>>
+    Attached(NameId),
+}
+assert_mem_size!(ParentScope, 16);
+
+impl ParentScope {
+    pub fn map_or<F, T>(&self, default: T, f: F) -> T
+    where
+        F: FnOnce(&NameId) -> T,
+    {
+        match self {
+            ParentScope::Some(id) | ParentScope::Attached(id) => f(id),
+            _ => default,
+        }
+    }
+
+    #[must_use]
+    pub fn as_ref(&self) -> Option<&NameId> {
+        match self {
+            ParentScope::Some(id) | ParentScope::Attached(id) => Some(id),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn is_none(&self) -> bool {
+        matches!(self, ParentScope::None)
+    }
+
+    #[must_use]
+    pub fn is_top_level(&self) -> bool {
+        matches!(self, ParentScope::TopLevel)
+    }
+
+    /// # Panics
+    ///
+    /// Panics if the `ParentScope` is None or `TopLevel`
+    #[must_use]
+    pub fn expect(&self, message: &str) -> NameId {
+        match self {
+            ParentScope::Some(id) | ParentScope::Attached(id) => *id,
+            _ => panic!("{}", message),
+        }
+    }
+}
+
+impl Display for ParentScope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParentScope::None => write!(f, "None"),
+            ParentScope::TopLevel => write!(f, "TopLevel"),
+            ParentScope::Some(id) => write!(f, "Some({id})"),
+            ParentScope::Attached(id) => write!(f, "Attached({id})"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq)]
+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
+    /// ```
+    parent_scope: ParentScope,
+    /// 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: u32,
+}
+
+impl PartialEq for Name {
+    fn eq(&self, other: &Self) -> bool {
+        self.str == other.str && self.parent_scope == other.parent_scope && self.nesting == other.nesting
+    }
+}
+assert_mem_size!(Name, 40);
+
+impl Name {
+    #[must_use]
+    pub fn new(str: StringId, parent_scope: ParentScope, 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) -> &ParentScope {
+        &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,
+            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
+    }
+
+    #[must_use]
+    pub fn nesting(&self) -> &Option<NameId> {
+        self.name.nesting()
+    }
+}
+
+/// 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) -> &ParentScope {
+        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) -> u32 {
+        match self {
+            NameRef::Unresolved(name) => name.ref_count,
+            NameRef::Resolved(resolved_name) => resolved_name.name.ref_count,
+        }
+    }
+
+    /// # Panics
+    ///
+    /// Panics if we exceed the maximum size of the reference count
+    pub fn increment_ref_count(&mut self, count: u32) {
+        let ref_count = match self {
+            NameRef::Unresolved(name) => &mut name.ref_count,
+            NameRef::Resolved(resolved_name) => &mut resolved_name.name.ref_count,
+        };
+        *ref_count = ref_count
+            .checked_add(count)
+            .expect("Should not exceed maximum name ref 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
+            }
+        }
+    }
+}
+
+impl PartialEq for NameRef {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (NameRef::Unresolved(a), NameRef::Unresolved(b)) => a == b,
+            (NameRef::Resolved(a), NameRef::Resolved(b)) => a.name == b.name,
+            (NameRef::Unresolved(name), NameRef::Resolved(resolved))
+            | (NameRef::Resolved(resolved), NameRef::Unresolved(name)) => **name == resolved.name,
+        }
+    }
+}
+
+impl PartialEq<Name> for NameRef {
+    fn eq(&self, other: &Name) -> bool {
+        match self {
+            NameRef::Unresolved(name) => **name == *other,
+            NameRef::Resolved(resolved_name) => &resolved_name.name == other,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn same_parent_scope_and_nesting() {
+        let name_1 = Name::new(StringId::from("Foo"), ParentScope::None, None);
+        let name_2 = Name::new(StringId::from("Foo"), ParentScope::None, None);
+        assert_eq!(name_1.id(), name_2.id());
+
+        let name_3 = Name::new(StringId::from("Foo"), ParentScope::Some(name_1.id()), None);
+        let name_4 = Name::new(StringId::from("Foo"), ParentScope::Some(name_2.id()), None);
+        assert_eq!(name_3.id(), name_4.id());
+
+        let name_5 = Name::new(StringId::from("Foo"), ParentScope::None, Some(name_1.id()));
+        let name_6 = Name::new(StringId::from("Foo"), ParentScope::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"),
+            ParentScope::Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+            Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+        );
+        let name_8 = Name::new(
+            StringId::from("Foo"),
+            ParentScope::Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+            Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+        );
+        assert_eq!(name_7.id(), name_8.id());
+    }
+}

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

@@ -0,0 +1,111 @@
+use crate::{
+    assert_mem_size,
+    model::ids::{ConstantReferenceId, MethodReferenceId, NameId, 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,
+}
+assert_mem_size!(ConstantReference, 24);
+
+impl ConstantReference {
+    #[must_use]
+    pub fn new(name_id: NameId, uri_id: UriId, offset: Offset) -> Self {
+        Self {
+            name_id,
+            uri_id,
+            offset,
+        }
+    }
+
+    #[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) -> ConstantReferenceId {
+        ConstantReferenceId::from(&format!(
+            "{}:{}:{}-{}",
+            self.name_id,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        ))
+    }
+}
+
+/// 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,
+    /// The receiver of the method call if it's a constant
+    receiver: Option<NameId>,
+}
+assert_mem_size!(MethodRef, 32);
+
+impl MethodRef {
+    #[must_use]
+    pub fn new(str: StringId, uri_id: UriId, offset: Offset, receiver: Option<NameId>) -> Self {
+        Self {
+            str,
+            uri_id,
+            offset,
+            receiver,
+        }
+    }
+
+    #[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 receiver(&self) -> Option<NameId> {
+        self.receiver
+    }
+
+    #[must_use]
+    pub fn id(&self) -> MethodReferenceId {
+        MethodReferenceId::from(&format!(
+            "{}:{}:{}-{}",
+            self.str,
+            self.uri_id,
+            self.offset.start(),
+            self.offset.end()
+        ))
+    }
+}

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

@@ -0,0 +1,50 @@
+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: u32,
+}
+
+impl StringRef {
+    #[must_use]
+    pub fn new(value: String) -> Self {
+        Self { value, ref_count: 1 }
+    }
+
+    #[must_use]
+    pub fn ref_count(&self) -> u32 {
+        self.ref_count
+    }
+
+    /// # Panics
+    ///
+    /// This function will panic if the reference count would exceed `u32::MAX`
+    pub fn increment_ref_count(&mut self, count: u32) {
+        self.ref_count = self
+            .ref_count
+            .checked_add(count)
+            .expect("Should not exceed maximum string ref 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,15 @@
+pub mod built_in;
+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 keywords;
+pub mod name;
+pub mod references;
+pub mod string_ref;
+pub mod visibility;

data/rust/rubydex/src/offset.rs

@@ -0,0 +1,147 @@
+//! 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.
+
+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`"),
+        )
+    }
+
+    /// # Panics
+    ///
+    /// This function can panic if the RBS location offsets don't fit into u32
+    #[must_use]
+    pub fn from_rbs_location(location: &ruby_rbs::node::RBSLocationRange) -> Self {
+        Self::new(
+            location
+                .start()
+                .try_into()
+                .expect("RBS location start offset should fit into u32"),
+            location
+                .end()
+                .try_into()
+                .expect("RBS location end offset should fit into 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`
+    #[must_use]
+    pub fn to_display_range(&self, document: &Document) -> String {
+        let loc = self.to_location(document).to_presentation();
+        format!(
+            "{}:{}-{}:{}",
+            loc.start_line(),
+            loc.start_col(),
+            loc.end_line(),
+            loc.end_col()
+        )
+    }
+
+    /// Converts this offset to a 0-indexed [`Location`] with start and end line/column numbers.
+    #[must_use]
+    pub fn to_location(&self, document: &Document) -> Location {
+        let line_index = document.line_index();
+        let start = line_index.line_col(self.start().into());
+        let end = line_index.line_col(self.end().into());
+        Location {
+            start_line: start.line,
+            start_col: start.col,
+            end_line: end.line,
+            end_col: end.col,
+        }
+    }
+}
+
+/// A resolved location within a file, with start and end line/column positions.
+/// Values are 0-indexed by default. Use [`to_presentation`](Location::to_presentation)
+/// for 1-indexed values suitable for display.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Location {
+    start_line: u32,
+    start_col: u32,
+    end_line: u32,
+    end_col: u32,
+}
+
+impl Location {
+    #[must_use]
+    pub fn start_line(&self) -> u32 {
+        self.start_line
+    }
+
+    #[must_use]
+    pub fn start_col(&self) -> u32 {
+        self.start_col
+    }
+
+    #[must_use]
+    pub fn end_line(&self) -> u32 {
+        self.end_line
+    }
+
+    #[must_use]
+    pub fn end_col(&self) -> u32 {
+        self.end_col
+    }
+
+    /// Returns a new `Location` with 1-indexed values for display purposes.
+    #[must_use]
+    pub fn to_presentation(&self) -> Self {
+        Self {
+            start_line: self.start_line + 1,
+            start_col: self.start_col + 1,
+            end_line: self.end_line + 1,
+            end_col: self.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;