rubydex 0.1.0.beta10 → 0.1.0.beta11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13a3cb3d4cbe536ab21b25d16a2ec0903b600dd2ffe90b062657c38cefc3dfbd
-  data.tar.gz: 43664af48f34fe8ca7cf006cc5a77548fad873df329b5f45c344aea0f34fff14
+  metadata.gz: d26e66bf7f1eac1c1bffa154b2a5e2c0621ce59883ae0367202cc82b6f85e64d
+  data.tar.gz: 3ea90f481e9717834e2be5e2a7dc1140810f842e738132496c211b5a19b6837b
 SHA512:
-  metadata.gz: 3e8f31a47de5aa62df61a57c9545a3b93155617e96fb4064ef95201c38c43949b524688e3ad8204471240dacc62f0f2e34b02fd49e2257fd181b1b9d69b0924a
-  data.tar.gz: c7ebeb6983652dfd86591054a954ee1ecb3b5bc55c00a43581014344c337f46e5ccc5b6539fe50e9861bd30ef7e88ba596e7734570575ed3dee3d3437c707519
+  metadata.gz: 24f8c2aa31a6d1ad76dd76486d005f3ee1e9143e0624b91db920c33e39da5b1bf248c431d0efc97996019f24f02ed8673912d4731509fcaaa59b1075c84378f9
+  data.tar.gz: 22b831aa47e08e9f3be4390054b645376e3e6d6974eeb2071e7e76499e1f9f056cdf0f0091eb1c28604047c2f0acea68a8e8f15a41ce939fa3acba13956e791f

data/ext/rubydex/definition.c

@@ -13,6 +13,7 @@ VALUE cSingletonClassDefinition;
 VALUE cModuleDefinition;
 VALUE cConstantDefinition;
 VALUE cConstantAliasDefinition;
+VALUE cConstantVisibilityDefinition;
 VALUE cMethodDefinition;
 VALUE cAttrAccessorDefinition;
 VALUE cAttrReaderDefinition;
@@ -36,6 +37,8 @@ VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
         return cConstantDefinition;
     case DefinitionKind_ConstantAlias:
         return cConstantAliasDefinition;
+    case DefinitionKind_ConstantVisibility:
+        return cConstantVisibilityDefinition;
     case DefinitionKind_Method:
         return cMethodDefinition;
     case DefinitionKind_AttrAccessor:
@@ -181,6 +184,7 @@ void rdxi_initialize_definition(VALUE mod) {
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
+    cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
     cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
     cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);

data/lib/rubydex/version.rb

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

data/rust/rubydex/src/diagnostic.rs

@@ -103,6 +103,7 @@ rules! {
     DynamicSingletonDefinition;
     DynamicAncestor;
     TopLevelMixinSelf;
+    InvalidPrivateConstant;
 
     // Resolution
 }

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

@@ -5,10 +5,10 @@ use crate::indexing::local_graph::LocalGraph;
 use crate::model::comment::Comment;
 use crate::model::definitions::{
     AttrAccessorDefinition, AttrReaderDefinition, AttrWriterDefinition, ClassDefinition, ClassVariableDefinition,
-    ConstantAliasDefinition, ConstantDefinition, Definition, DefinitionFlags, ExtendDefinition,
-    GlobalVariableAliasDefinition, GlobalVariableDefinition, IncludeDefinition, InstanceVariableDefinition,
-    MethodAliasDefinition, MethodDefinition, Mixin, ModuleDefinition, Parameter, ParameterStruct, PrependDefinition,
-    Receiver, Signatures, SingletonClassDefinition,
+    ConstantAliasDefinition, ConstantDefinition, ConstantVisibilityDefinition, Definition, DefinitionFlags,
+    ExtendDefinition, GlobalVariableAliasDefinition, GlobalVariableDefinition, IncludeDefinition,
+    InstanceVariableDefinition, MethodAliasDefinition, MethodDefinition, Mixin, ModuleDefinition, Parameter,
+    ParameterStruct, PrependDefinition, Receiver, Signatures, SingletonClassDefinition,
 };
 use crate::model::document::Document;
 use crate::model::ids::{DefinitionId, NameId, StringId, UriId};
@@ -1164,6 +1164,94 @@ impl<'a> RubyIndexer<'a> {
             .add_constant_reference(ConstantReference::new(new_name_id, self.uri_id, offset));
         Some(new_name_id)
     }
+
+    fn handle_constant_visibility(&mut self, node: &ruby_prism::CallNode, visibility: Visibility) {
+        let receiver = node.receiver();
+
+        let receiver_name_id = match receiver {
+            Some(ruby_prism::Node::ConstantPathNode { .. } | ruby_prism::Node::ConstantReadNode { .. }) => {
+                self.index_constant_reference(&receiver.unwrap(), true)
+            }
+            Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
+                Some(Nesting::Method(_)) => {
+                    // Dynamic private constant (called from a method), we ignore it but don't report an error since it's valid Ruby
+                    // if being called from a singleton method.
+
+                    return;
+                }
+                None => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidPrivateConstant,
+                        Offset::from_prism_location(&node.location()),
+                        "Private constant called at top level".to_string(),
+                    );
+
+                    return;
+                }
+                _ => None,
+            },
+            _ => {
+                self.local_graph.add_diagnostic(
+                    Rule::InvalidPrivateConstant,
+                    Offset::from_prism_location(&node.location()),
+                    "Dynamic receiver for private constant".to_string(),
+                );
+
+                return;
+            }
+        };
+
+        let Some(arguments) = node.arguments() else {
+            return;
+        };
+
+        for argument in &arguments.arguments() {
+            let (name, location) = match argument {
+                ruby_prism::Node::SymbolNode { .. } => {
+                    let symbol = argument.as_symbol_node().unwrap();
+                    if let Some(value_loc) = symbol.value_loc() {
+                        (Self::location_to_string(&value_loc), value_loc)
+                    } else {
+                        continue;
+                    }
+                }
+                ruby_prism::Node::StringNode { .. } => {
+                    let string = argument.as_string_node().unwrap();
+                    let name = String::from_utf8_lossy(string.unescaped()).to_string();
+                    (name, argument.location())
+                }
+                _ => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidPrivateConstant,
+                        Offset::from_prism_location(&argument.location()),
+                        "Private constant called with non-symbol argument".to_string(),
+                    );
+
+                    return;
+                }
+            };
+
+            let str_id = self.local_graph.intern_string(name);
+            let offset = Offset::from_prism_location(&location);
+            let definition = Definition::ConstantVisibility(Box::new(ConstantVisibilityDefinition::new(
+                self.local_graph.add_name(Name::new(
+                    str_id,
+                    receiver_name_id.map_or(ParentScope::None, ParentScope::Some),
+                    self.current_lexical_scope_name_id(),
+                )),
+                visibility,
+                self.uri_id,
+                offset,
+                Vec::new(),
+                DefinitionFlags::empty(),
+                self.current_nesting_definition_id(),
+            )));
+
+            let definition_id = self.local_graph.add_definition(definition);
+
+            self.add_member_to_current_owner(definition_id);
+        }
+    }
 }
 
 struct CommentGroup {
@@ -1845,6 +1933,12 @@ impl Visit<'_> for RubyIndexer<'_> {
 
                 self.index_method_reference_for_call(node);
             }
+            "private_constant" => {
+                self.handle_constant_visibility(node, Visibility::Private);
+            }
+            "public_constant" => {
+                self.handle_constant_visibility(node, Visibility::Public);
+            }
             _ => {
                 // For method calls that we don't explicitly handle each part, we continue visiting their parts as we
                 // may discover something inside
@@ -2229,22 +2323,35 @@ mod tests {
         }};
     }
 
-    /// Asserts that a method reference has the expected receiver.
+    /// Asserts that exactly one method reference with the given name has the expected receiver.
     ///
-    /// Finds a `MethodRef` by name and checks its receiver's string representation.
+    /// Panics if there isn't exactly one `MethodRef` with that name.
     ///
     /// Usage:
     /// - `assert_method_ref_receiver!(context, "bar", "<Foo>")`
     macro_rules! assert_method_ref_receiver {
         ($context:expr, $method_name:expr, $expected_receiver:expr) => {{
-            let method_ref = $context
+            let target = StringId::from($method_name);
+            let matches: Vec<_> = $context
                 .graph()
                 .method_references()
                 .values()
-                .find(|method_ref| *method_ref.str() == StringId::from($method_name))
-                .unwrap_or_else(|| panic!("should have a method reference for {}", $method_name));
+                .filter(|method_ref| *method_ref.str() == target)
+                .collect();
+
+            assert_eq!(
+                matches.len(),
+                1,
+                "expected exactly one method reference for `{}`, found {}",
+                $method_name,
+                matches.len()
+            );
 
-            let receiver = $context.graph().names().get(&method_ref.receiver().unwrap()).unwrap();
+            let method_ref = matches[0];
+            let receiver_id = method_ref
+                .receiver()
+                .unwrap_or_else(|| panic!("method reference for `{}` has no receiver", $method_name));
+            let receiver = $context.graph().names().get(&receiver_id).unwrap();
 
             assert_eq!(
                 StringId::from($expected_receiver),
@@ -6469,6 +6576,101 @@ mod tests {
             assert_promotable!(def);
         });
     }
+
+    #[test]
+    fn index_private_constant_calls() {
+        let context = index_source({
+            r#"
+            module Foo
+              BAR = 42
+              BAZ = 43
+              FOO = 44
+
+              private_constant :BAR, :BAZ
+              private_constant "FOO"
+
+              class Qux
+                BAR = 42
+                BAZ = 43
+
+                Foo.public_constant :BAR
+                Foo.public_constant "BAZ"
+              end
+
+              self.private_constant :Qux
+            end
+
+            Foo.public_constant :BAR
+            "#
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "6:21-6:24", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "BAR");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "6:27-6:30", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "BAZ");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "7:20-7:25", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "FOO");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "13:26-13:29", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "Foo::BAR");
+            assert_eq!(def.visibility(), &Visibility::Public);
+        });
+        assert_definition_at!(&context, "14:25-14:30", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "Foo::BAZ");
+            assert_eq!(def.visibility(), &Visibility::Public);
+        });
+        assert_definition_at!(&context, "17:26-17:29", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "Qux");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "20:22-20:25", ConstantVisibility, |def| {
+            assert_def_name_eq!(&context, def, "Foo::BAR");
+            assert_eq!(def.visibility(), &Visibility::Public);
+        });
+    }
+
+    #[test]
+    fn index_private_constant_calls_diagnostics() {
+        let context = index_source({
+            "
+            private_constant :NOT_INDEXED
+            self.private_constant :NOT_INDEXED
+            foo.private_constant :NOT_INDEXED # not indexed, dynamic receiver
+
+            module Foo
+              private_constant NOT_INDEXED, not_indexed # not indexed, not a symbol
+              private_constant # not indexed, no arguments
+
+              def self.qux
+                private_constant :Bar # not indexed, dynamic
+              end
+
+              def foo
+                private_constant :Bar # not indexed, dynamic
+              end
+            end
+            "
+        });
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-private-constant: Private constant called at top level (1:1-1:30)",
+                "invalid-private-constant: Private constant called at top level (2:1-2:35)",
+                "invalid-private-constant: Dynamic receiver for private constant (3:1-3:34)",
+                "invalid-private-constant: Private constant called with non-symbol argument (6:20-6:31)",
+            ]
+        );
+
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo::Qux, Foo#foo
+    }
 }
 
 #[cfg(test)]

data/rust/rubydex/src/indexing.rs

@@ -95,7 +95,7 @@ impl Job for IndexingJob {
 /// Indexes a single source string in memory, dispatching to the appropriate indexer based on `language_id`.
 pub fn index_source(graph: &mut Graph, uri: &str, source: &str, language_id: &LanguageId) {
     let local_graph = build_local_graph(uri.to_string(), source, language_id);
-    graph.update(local_graph);
+    graph.consume_document_changes(local_graph);
 }
 
 /// Indexes the given paths, reading the content from disk and populating the given `Graph` instance.
@@ -123,7 +123,7 @@ pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>) -> Vec<Errors> {
 
     // Merge graphs as they arrive, overlapping with indexing work on other threads.
     while let Ok(local_graph) = local_graphs_rx.recv() {
-        graph.update(local_graph);
+        graph.consume_document_changes(local_graph);
     }
 
     for handle in handles {

data/rust/rubydex/src/main.rs

@@ -94,7 +94,7 @@ fn main() {
 
     time_it!(resolution, {
         let mut resolver = Resolver::new(&mut graph);
-        resolver.resolve_all();
+        resolver.resolve();
     });
 
     if let Some(StopAfter::Resolution) = args.stop_after {

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

@@ -482,6 +482,10 @@ impl Namespace {
         all_namespaces!(self, it => it.member(str_id))
     }
 
+    pub fn remove_member(&mut self, str_id: &StringId) -> Option<DeclarationId> {
+        all_namespaces!(self, it => it.remove_member(str_id))
+    }
+
     #[must_use]
     pub fn singleton_class(&self) -> Option<&DeclarationId> {
         all_namespaces!(self, it => it.singleton_class_id())

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

@@ -62,6 +62,7 @@ pub enum Definition {
     Module(Box<ModuleDefinition>),
     Constant(Box<ConstantDefinition>),
     ConstantAlias(Box<ConstantAliasDefinition>),
+    ConstantVisibility(Box<ConstantVisibilityDefinition>),
     Method(Box<MethodDefinition>),
     AttrAccessor(Box<AttrAccessorDefinition>),
     AttrReader(Box<AttrReaderDefinition>),
@@ -82,6 +83,7 @@ macro_rules! all_definitions {
             Definition::Module($var) => $expr,
             Definition::Constant($var) => $expr,
             Definition::ConstantAlias($var) => $expr,
+            Definition::ConstantVisibility($var) => $expr,
             Definition::GlobalVariable($var) => $expr,
             Definition::InstanceVariable($var) => $expr,
             Definition::ClassVariable($var) => $expr,
@@ -129,6 +131,7 @@ impl Definition {
             Definition::Module(_) => "Module",
             Definition::Constant(_) => "Constant",
             Definition::ConstantAlias(_) => "ConstantAlias",
+            Definition::ConstantVisibility(_) => "ConstantVisibility",
             Definition::Method(_) => "Method",
             Definition::AttrAccessor(_) => "AttrAccessor",
             Definition::AttrReader(_) => "AttrReader",
@@ -149,6 +152,7 @@ impl Definition {
             Definition::Module(d) => Some(d.name_id()),
             Definition::Constant(d) => Some(d.name_id()),
             Definition::ConstantAlias(d) => Some(d.name_id()),
+            Definition::ConstantVisibility(d) => Some(d.name_id()),
             Definition::GlobalVariable(_)
             | Definition::InstanceVariable(_)
             | Definition::ClassVariable(_)
@@ -701,6 +705,80 @@ impl ConstantAliasDefinition {
     }
 }
 
+#[derive(Debug)]
+pub struct ConstantVisibilityDefinition {
+    name_id: NameId,
+    visibility: Visibility,
+    uri_id: UriId,
+    offset: Offset,
+    flags: DefinitionFlags,
+    comments: Vec<Comment>,
+    lexical_nesting_id: Option<DefinitionId>,
+}
+
+impl ConstantVisibilityDefinition {
+    #[must_use]
+    pub const fn new(
+        name_id: NameId,
+        visibility: Visibility,
+        uri_id: UriId,
+        offset: Offset,
+        comments: Vec<Comment>,
+        flags: DefinitionFlags,
+        lexical_nesting_id: Option<DefinitionId>,
+    ) -> Self {
+        Self {
+            name_id,
+            visibility,
+            uri_id,
+            offset,
+            flags,
+            comments,
+            lexical_nesting_id,
+        }
+    }
+
+    #[must_use]
+    pub fn id(&self) -> DefinitionId {
+        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+    }
+
+    #[must_use]
+    pub fn name_id(&self) -> &NameId {
+        &self.name_id
+    }
+
+    #[must_use]
+    pub fn visibility(&self) -> &Visibility {
+        &self.visibility
+    }
+
+    #[must_use]
+    pub fn uri_id(&self) -> &UriId {
+        &self.uri_id
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn comments(&self) -> &[Comment] {
+        &self.comments
+    }
+
+    #[must_use]
+    pub fn lexical_nesting_id(&self) -> &Option<DefinitionId> {
+        &self.lexical_nesting_id
+    }
+
+    #[must_use]
+    pub fn flags(&self) -> &DefinitionFlags {
+        &self.flags
+    }
+}
+
 /// The signature of a method
 ///
 /// Currently only supports the parameter names and kinds.