rubydex 0.1.0.beta8 → 0.1.0.beta9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c07115229a5715e4501adce61eefbb4bfe26694f7945736829230d77e97c65a
-  data.tar.gz: 5e845ff2cc4617790785c6cca4f5f67a0cfb02d02d88721062b39fff75e715d1
+  metadata.gz: d9838707935ff868fb005a0d85254747ea6e3a5b5871c0626f5ec6641e0878e2
+  data.tar.gz: 87f4157545d244bfb3bb7e869914dc355d1d2b3dd0e181e439ce81ce1073cdc5
 SHA512:
-  metadata.gz: 0e5103b95c2123cae03d2f40a1e39ef642aee65b47f99416b034a0f40365bf8535a8829794df393274155bf5e548c44a412457e00fdf8701922e08a9926e3b27
-  data.tar.gz: 478a4a347f1c95210e69e00c2e609abd6ed1c090bae1a5bf30266ade51efc68eaaa294a3f5371d6890497b5d9a782dc0d42c1009c7440d28a1030753a6a03647
+  metadata.gz: 7a69359f6261bb54eb0f576fbb9c31b85eb209c45fdb60d81d5f965abed05ac535409191b8a87376bcabe8278149ef1f87c8097162204d583f1ed2670bea7d5e
+  data.tar.gz: 862070c2cd67d83aae2da083987235017610d9637d6b90b49b8270a6ab8d3c4a1914333e30152f025f3e24e317fd3b3d0a74f3f20e64ffcf25752503c40baa7f

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.1.0.beta8"
+  VERSION = "0.1.0.beta9"
 end

data/rust/Cargo.toml

@@ -12,6 +12,11 @@ lto = true
 opt-level = 3
 codegen-units = 1
 
+[profile.profiling]
+inherits = "release"
+debug = true
+strip = false
+
 [workspace.lints.clippy]
 # See: https://doc.rust-lang.org/clippy/lints.html
 correctness = "deny"

data/rust/rubydex/src/indexing/local_graph.rs

@@ -3,6 +3,7 @@ use std::collections::hash_map::Entry;
 use crate::diagnostic::{Diagnostic, Rule};
 use crate::model::definitions::Definition;
 use crate::model::document::Document;
+use crate::model::graph::NameDependent;
 use crate::model::identity_maps::IdentityHashMap;
 use crate::model::ids::{DefinitionId, NameId, ReferenceId, StringId, UriId};
 use crate::model::name::{Name, NameRef};
@@ -18,6 +19,7 @@ type LocalGraphParts = (
     IdentityHashMap<NameId, NameRef>,
     IdentityHashMap<ReferenceId, ConstantReference>,
     IdentityHashMap<ReferenceId, MethodRef>,
+    IdentityHashMap<NameId, Vec<NameDependent>>,
 );
 
 #[derive(Debug)]
@@ -29,6 +31,7 @@ pub struct LocalGraph {
     names: IdentityHashMap<NameId, NameRef>,
     constant_references: IdentityHashMap<ReferenceId, ConstantReference>,
     method_references: IdentityHashMap<ReferenceId, MethodRef>,
+    name_dependents: IdentityHashMap<NameId, Vec<NameDependent>>,
 }
 
 impl LocalGraph {
@@ -42,6 +45,7 @@ impl LocalGraph {
             names: IdentityHashMap::default(),
             constant_references: IdentityHashMap::default(),
             method_references: IdentityHashMap::default(),
+            name_dependents: IdentityHashMap::default(),
         }
     }
 
@@ -70,6 +74,13 @@ impl LocalGraph {
     pub fn add_definition(&mut self, definition: Definition) -> DefinitionId {
         let definition_id = definition.id();
 
+        if let Some(name_id) = definition.name_id() {
+            self.name_dependents
+                .entry(*name_id)
+                .or_default()
+                .push(NameDependent::Definition(definition_id));
+        }
+
         if self.definitions.insert(definition_id, definition).is_some() {
             debug_assert!(false, "DefinitionId collision in local graph");
         }
@@ -117,6 +128,18 @@ impl LocalGraph {
                 entry.get_mut().increment_ref_count(1);
             }
             Entry::Vacant(entry) => {
+                if let Some(&parent_scope) = name.parent_scope().as_ref() {
+                    self.name_dependents
+                        .entry(parent_scope)
+                        .or_default()
+                        .push(NameDependent::ChildName(name_id));
+                }
+                if let Some(&nesting_id) = name.nesting().as_ref() {
+                    self.name_dependents
+                        .entry(nesting_id)
+                        .or_default()
+                        .push(NameDependent::NestedName(name_id));
+                }
                 entry.insert(NameRef::Unresolved(Box::new(name)));
             }
         }
@@ -133,6 +156,10 @@ impl LocalGraph {
 
     pub fn add_constant_reference(&mut self, reference: ConstantReference) -> ReferenceId {
         let reference_id = reference.id();
+        self.name_dependents
+            .entry(*reference.name_id())
+            .or_default()
+            .push(NameDependent::Reference(reference_id));
 
         if self.constant_references.insert(reference_id, reference).is_some() {
             debug_assert!(false, "ReferenceId collision in local graph");
@@ -172,6 +199,13 @@ impl LocalGraph {
         self.document.add_diagnostic(diagnostic);
     }
 
+    // Name dependents
+
+    #[must_use]
+    pub fn name_dependents(&self) -> &IdentityHashMap<NameId, Vec<NameDependent>> {
+        &self.name_dependents
+    }
+
     // Into parts
 
     #[must_use]
@@ -184,6 +218,7 @@ impl LocalGraph {
             self.names,
             self.constant_references,
             self.method_references,
+            self.name_dependents,
         )
     }
 }

data/rust/rubydex/src/indexing/rbs_indexer.rs

@@ -1,8 +1,8 @@
 //! Visit the RBS AST and create type definitions.
 
 use ruby_rbs::node::{
-    self, ClassNode, CommentNode, ConstantNode, ExtendNode, GlobalNode, IncludeNode, ModuleNode, Node, NodeList,
-    PrependNode, TypeNameNode, Visit,
+    self, AliasKind, ClassNode, CommentNode, ConstantNode, ExtendNode, GlobalNode, IncludeNode, ModuleNode, Node,
+    NodeList, PrependNode, TypeNameNode, Visit,
 };
 
 use crate::diagnostic::Rule;
@@ -10,7 +10,7 @@ use crate::indexing::local_graph::LocalGraph;
 use crate::model::comment::Comment;
 use crate::model::definitions::{
     ClassDefinition, ConstantDefinition, Definition, DefinitionFlags, ExtendDefinition, GlobalVariableDefinition,
-    IncludeDefinition, Mixin, ModuleDefinition, PrependDefinition,
+    IncludeDefinition, MethodAliasDefinition, Mixin, ModuleDefinition, PrependDefinition, Receiver,
 };
 use crate::model::document::Document;
 use crate::model::ids::{DefinitionId, NameId, ReferenceId, UriId};
@@ -147,14 +147,52 @@ impl<'a> RBSIndexer<'a> {
         }
     }
 
-    fn collect_comments(comment_node: Option<CommentNode>) -> Vec<Comment> {
-        comment_node
-            .into_iter()
-            .map(|comment| {
-                let text = Self::bytes_to_string(comment.string().as_bytes());
-                Comment::new(Offset::from_rbs_location(&comment.location()), text)
-            })
-            .collect()
+    #[allow(clippy::cast_possible_truncation)]
+    fn collect_comments(&self, comment_node: Option<CommentNode>) -> Box<[Comment]> {
+        let Some(comment_node) = comment_node else {
+            return Box::new([]);
+        };
+
+        let location = comment_node.location();
+        let start = location.start().cast_unsigned() as usize;
+        let end = location.end().cast_unsigned() as usize;
+
+        let comment_block = &self.source[start..end];
+        let lines: Vec<&str> = comment_block.split('\n').collect();
+
+        let mut comments = Vec::with_capacity(lines.len());
+        let mut current_offset = start as u32;
+
+        for (i, line) in lines.iter().enumerate() {
+            let mut size = 1;
+            let mut line = *line;
+
+            if line.ends_with('\r') {
+                line = line.trim_end_matches('\r');
+                size += 1;
+            }
+
+            let line_indent = if i == 0 {
+                0
+            } else {
+                line.len() - line.trim_start().len()
+            };
+
+            // Skip past indentation to the comment text
+            current_offset += line_indent as u32;
+
+            let line_text = line[line_indent..].to_string();
+            let line_bytes = line_text.len() as u32;
+            let offset = Offset::new(current_offset, current_offset + line_bytes);
+            comments.push(Comment::new(offset, line_text));
+
+            // Advance past current line text + \r (if present) + \n for the next line
+            if i < lines.len() - 1 {
+                current_offset += line_bytes + size;
+            }
+        }
+
+        comments.into_boxed_slice()
     }
 
     fn register_definition(
@@ -201,7 +239,7 @@ impl Visit for RBSIndexer<'_> {
         let offset = Offset::from_rbs_location(&class_node.location());
         let name_offset = Offset::from_rbs_location(&type_name.name().location());
 
-        let comments = Self::collect_comments(class_node.comment());
+        let comments = self.collect_comments(class_node.comment());
 
         let superclass_ref = class_node.super_class().as_ref().map(|super_node| {
             let type_name = super_node.name();
@@ -241,7 +279,7 @@ impl Visit for RBSIndexer<'_> {
         let offset = Offset::from_rbs_location(&module_node.location());
         let name_offset = Offset::from_rbs_location(&type_name.name().location());
 
-        let comments = Self::collect_comments(module_node.comment());
+        let comments = self.collect_comments(module_node.comment());
 
         let definition = Definition::Module(Box::new(ModuleDefinition::new(
             name_id,
@@ -271,7 +309,7 @@ impl Visit for RBSIndexer<'_> {
         let name_id = self.index_type_name(&type_name, nesting_name_id);
         let offset = Offset::from_rbs_location(&constant_node.location());
 
-        let comments = Self::collect_comments(constant_node.comment());
+        let comments = self.collect_comments(constant_node.comment());
 
         let definition = Definition::Constant(Box::new(ConstantDefinition::new(
             name_id,
@@ -293,7 +331,7 @@ impl Visit for RBSIndexer<'_> {
             .intern_string(Self::bytes_to_string(global_node.name().name()));
         let offset = Offset::from_rbs_location(&global_node.location());
 
-        let comments = Self::collect_comments(global_node.comment());
+        let comments = self.collect_comments(global_node.comment());
 
         let definition = Definition::GlobalVariable(Box::new(GlobalVariableDefinition::new(
             str_id,
@@ -324,6 +362,37 @@ impl Visit for RBSIndexer<'_> {
             Mixin::Extend(ExtendDefinition::new(ref_id))
         });
     }
+
+    fn visit_alias_node(&mut self, alias_node: &node::AliasNode) {
+        let lexical_nesting_id = self.parent_lexical_scope_id();
+
+        let receiver = match alias_node.kind() {
+            AliasKind::Instance => None,
+            AliasKind::Singleton => lexical_nesting_id.map(Receiver::SelfReceiver),
+        };
+
+        let new_name = Self::bytes_to_string(alias_node.new_name().name());
+        let old_name = Self::bytes_to_string(alias_node.old_name().name());
+
+        let new_name_str_id = self.local_graph.intern_string(format!("{new_name}()"));
+        let old_name_str_id = self.local_graph.intern_string(format!("{old_name}()"));
+
+        let offset = Offset::from_rbs_location(&alias_node.location());
+        let comments = self.collect_comments(alias_node.comment());
+
+        let definition = Definition::MethodAlias(Box::new(MethodAliasDefinition::new(
+            new_name_str_id,
+            old_name_str_id,
+            self.uri_id,
+            offset,
+            comments,
+            Self::flags(&alias_node.annotations()),
+            lexical_nesting_id,
+            receiver,
+        )));
+
+        self.register_definition(definition, lexical_nesting_id);
+    }
 }
 
 #[cfg(test)]
@@ -331,11 +400,12 @@ mod tests {
     use ruby_rbs::node::{self, Node, NodeList};
 
     use crate::indexing::rbs_indexer::RBSIndexer;
-    use crate::model::definitions::DefinitionFlags;
+    use crate::model::definitions::{Definition, DefinitionFlags};
     use crate::test_utils::LocalGraphTest;
     use crate::{
         assert_def_comments_eq, assert_def_mixins_eq, assert_def_name_eq, assert_def_name_offset_eq, assert_def_str_eq,
-        assert_def_superclass_ref_eq, assert_definition_at, assert_local_diagnostics_eq, assert_no_local_diagnostics,
+        assert_def_superclass_ref_eq, assert_definition_at, assert_local_diagnostics_eq, assert_method_has_receiver,
+        assert_no_local_diagnostics, assert_string_eq,
     };
 
     fn index_source(source: &str) -> LocalGraphTest {
@@ -526,7 +596,7 @@ mod tests {
 
         assert_definition_at!(&context, "2:1-2:12", Constant, |def| {
             assert_def_name_eq!(&context, def, "FOO");
-            assert_def_comments_eq!(&context, def, ["Some documentation\n"]);
+            assert_def_comments_eq!(&context, def, ["# Some documentation"]);
         });
     }
 
@@ -551,7 +621,7 @@ mod tests {
 
         assert_definition_at!(&context, "4:1-4:14", GlobalVariable, |def| {
             assert_def_str_eq!(&context, def, "$bar");
-            assert_def_comments_eq!(&context, def, ["A global variable\n"]);
+            assert_def_comments_eq!(&context, def, ["# A global variable"]);
         });
     }
 
@@ -714,4 +784,155 @@ mod tests {
             assert!(def.flags().contains(DefinitionFlags::DEPRECATED));
         });
     }
+
+    #[test]
+    fn index_alias_node() {
+        let context = index_source({
+            "
+            class Foo
+              # Some documentation
+              alias bar baz
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-4:4", Class, |class_def| {
+            assert_eq!(1, class_def.members().len());
+
+            assert_definition_at!(&context, "3:3-3:16", MethodAlias, |def| {
+                assert_string_eq!(&context, def.new_name_str_id(), "bar()");
+                assert_string_eq!(&context, def.old_name_str_id(), "baz()");
+                assert_def_comments_eq!(&context, def, ["# Some documentation"]);
+                assert_eq!(class_def.id(), def.lexical_nesting_id().unwrap());
+            });
+        });
+    }
+
+    #[test]
+    fn index_alias_node_with_deprecation() {
+        let context = index_source({
+            "
+            class Foo
+              %a{deprecated}
+              alias bar baz
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "3:3-3:16", MethodAlias, |def| {
+            assert!(def.flags().contains(DefinitionFlags::DEPRECATED));
+        });
+    }
+
+    #[test]
+    fn index_alias_node_singleton() {
+        let context = index_source({
+            "
+            class Foo
+              alias self.bar self.baz
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 2);
+
+        assert_definition_at!(&context, "2:3-2:26", MethodAlias, |def| {
+            assert_string_eq!(&context, def.new_name_str_id(), "bar()");
+            assert_string_eq!(&context, def.old_name_str_id(), "baz()");
+            assert_method_has_receiver!(&context, def, "Foo");
+        });
+    }
+
+    #[test]
+    fn mixed_singleton_instance_alias_is_not_indexed() {
+        // Mixed aliases (`alias self.x y` and `alias x self.y`) are not valid RBS.
+        // Verify that no alias definitions are produced for these inputs.
+        for source in [
+            "
+            class Foo
+              alias self.bar baz
+            end
+            ",
+            "
+            class Foo
+              alias bar self.baz
+            end
+            ",
+        ] {
+            let context = index_source(source);
+            let has_alias = context
+                .graph()
+                .definitions()
+                .values()
+                .any(|d| matches!(d, Definition::MethodAlias(_)));
+            assert!(!has_alias, "Expected no alias definitions for: {source}");
+        }
+    }
+
+    #[test]
+    fn split_multiline_comments() {
+        let context = index_source({
+            "
+            # First line
+            # Second line
+            # Third line
+            class Foo
+              # A comment for Bar
+                # Another line for Bar
+            # One more line for Bar
+              module Bar
+              end
+            end
+
+            # splits strings at the \\n char
+            BAZ: Integer
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "4:1-10:4", Class, |def| {
+            assert_def_name_eq!(&context, def, "Foo");
+            assert_def_comments_eq!(&context, def, ["# First line", "# Second line", "# Third line"]);
+        });
+
+        assert_definition_at!(&context, "8:3-9:6", Module, |def| {
+            assert_def_name_eq!(&context, def, "Bar");
+            assert_def_comments_eq!(
+                &context,
+                def,
+                [
+                    "# A comment for Bar",
+                    "# Another line for Bar",
+                    "# One more line for Bar"
+                ]
+            );
+        });
+
+        assert_definition_at!(&context, "13:1-13:13", Constant, |def| {
+            assert_def_name_eq!(&context, def, "BAZ");
+            assert_def_comments_eq!(&context, def, ["# splits strings at the \\n char"]);
+        });
+    }
+
+    #[test]
+    fn split_multiline_comments_crlf() {
+        // Build the indexer directly to bypass normalize_indentation, which strips \r
+        let source = "# First line\r\n# Second line\r\nclass Foo\r\nend\r\n";
+        let mut indexer = RBSIndexer::new("file:///foo.rbs".to_string(), source);
+        indexer.index();
+        let context = LocalGraphTest::from_local_graph("file:///foo.rbs", indexer.local_graph());
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "3:1-4:4", Class, |def| {
+            assert_def_name_eq!(&context, def, "Foo");
+            assert_def_comments_eq!(&context, def, ["# First line", "# Second line"]);
+        });
+    }
 }