rubydex 0.2.0-aarch64-linux → 0.2.2-aarch64-linux

data/rbi/rubydex.rbi

@@ -152,6 +152,7 @@ class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
 class Rubydex::MethodAliasDefinition < Rubydex::Definition; end
 class Rubydex::MethodDefinition < Rubydex::Definition; end
+
 class Rubydex::ModuleDefinition < Rubydex::Definition
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
@@ -317,27 +318,56 @@ class Rubydex::Graph
   # Returns completion candidates for an expression context. This includes all keywords, constants, methods, instance
   # variables, class variables and global variables reachable from the current lexical scope and self type.
   #
-  # The nesting array represents the lexical scope stack, where the last element is the self type. An empty array
-  # defaults to `Object` as the self type (top-level context).
-  sig { params(nesting: T::Array[String]).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword)]) }
-  def complete_expression(nesting); end
+  # The nesting array represents the lexical scope stack. The optional `self_receiver` keyword argument overrides the
+  # self type independently of the lexical scope (e.g., `"Foo::<Foo>"` for `def Foo.bar`). This distinction is important
+  # because constants and class variables are always attached to the lexical scope. Meanwhile, methods and instance
+  # variables are attached to the type of `self` and those don't always match.
+  sig do
+    params(
+      nesting: T::Array[String],
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword)])
+  end
+  def complete_expression(nesting, self_receiver: nil); end
 
   # Returns completion candidates after a namespace access operator (e.g., `Foo::`). This includes all constants and
   # singleton methods for the namespace and its ancestors.
-  sig { params(name: String).returns(T::Array[Rubydex::Declaration]) }
-  def complete_namespace_access(name); end
+  #
+  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used to filter visibility-restricted
+  # singleton methods (e.g., `private_class_method`). Pass `nil` (the default) for top-level/script scope.
+  sig do
+    params(
+      name: String,
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[Rubydex::Declaration])
+  end
+  def complete_namespace_access(name, self_receiver: nil); end
 
   # Returns completion candidates after a method call operator (e.g., `foo.`). This includes all methods that exist on
   # the type of the receiver and its ancestors.
-  sig { params(name: String).returns(T::Array[Rubydex::Method]) }
-  def complete_method_call(name); end
+  #
+  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used for visibility checks for `private`
+  # and `protected` methods. Pass `nil` (the default) for top-level/script scope.
+  sig do
+    params(
+      name: String,
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[Rubydex::Method])
+  end
+  def complete_method_call(name, self_receiver: nil); end
 
   # Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`). This includes everything
   # that expression completion provides plus keyword argument names of the method being called.
   #
-  # The nesting array represents the lexical scope stack, where the last element is the self type.
-  sig { params(name: String, nesting: T::Array[String]).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword, Rubydex::KeywordParameter)]) }
-  def complete_method_argument(name, nesting); end
+  # See `complete_expression` for the semantics of `nesting` and `self_receiver`.
+  sig do
+    params(
+      name: String,
+      nesting: T::Array[String],
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword, Rubydex::KeywordParameter)])
+  end
+  def complete_method_argument(name, nesting, self_receiver: nil); end
 
   private
 

data/rust/rubydex/src/diagnostic.rs

@@ -108,4 +108,5 @@ rules! {
 
     // Resolution
     UndefinedMethodVisibilityTarget;
+    UndefinedConstantVisibilityTarget;
 }

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

@@ -1200,9 +1200,7 @@ impl<'a> RubyIndexer<'a> {
             }
             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.
-
+                    self.visit_call_node_parts(node);
                     return;
                 }
                 None => {
@@ -1211,7 +1209,7 @@ impl<'a> RubyIndexer<'a> {
                         Offset::from_prism_location(&node.location()),
                         "Private constant called at top level".to_string(),
                     );
-
+                    self.visit_call_node_parts(node);
                     return;
                 }
                 _ => None,
@@ -1222,7 +1220,7 @@ impl<'a> RubyIndexer<'a> {
                     Offset::from_prism_location(&node.location()),
                     "Dynamic receiver for private constant".to_string(),
                 );
-
+                self.visit_call_node_parts(node);
                 return;
             }
         };
@@ -1252,19 +1250,16 @@ impl<'a> RubyIndexer<'a> {
                         Offset::from_prism_location(&argument.location()),
                         "Private constant called with non-symbol argument".to_string(),
                     );
-
-                    return;
+                    self.visit(&argument);
+                    continue;
                 }
             };
 
             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(),
-                )),
+                receiver_name_id,
+                str_id,
                 visibility,
                 self.uri_id,
                 offset,
@@ -1279,6 +1274,60 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
+    fn handle_singleton_method_visibility(
+        &mut self,
+        node: &ruby_prism::CallNode,
+        visibility: Visibility,
+        call_name: &str,
+    ) {
+        match node.receiver() {
+            Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
+                Some(Nesting::Method(_)) => {
+                    self.visit_call_node_parts(node);
+                    return;
+                }
+                None => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&node.location()),
+                        format!("`{call_name}` called at top level"),
+                    );
+                    self.visit_call_node_parts(node);
+                    return;
+                }
+                _ => {}
+            },
+            _ => {
+                self.visit_call_node_parts(node);
+                return;
+            }
+        }
+
+        let Some(arguments) = node.arguments() else {
+            return;
+        };
+
+        for argument in &arguments.arguments() {
+            match argument {
+                ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. } => {
+                    self.create_method_visibility_definition(
+                        &argument,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                }
+                _ => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&argument.location()),
+                        format!("`{call_name}` called with a non-literal argument"),
+                    );
+                    self.visit(&argument);
+                }
+            }
+        }
+    }
+
     fn is_attr_call(arg: &ruby_prism::Node) -> bool {
         arg.as_call_node().is_some_and(|call| {
             let receiver = call.receiver();
@@ -1316,7 +1365,7 @@ impl<'a> RubyIndexer<'a> {
                 arg,
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. }
             ) {
-                self.create_method_visibility_definition(&arg, visibility);
+                self.create_method_visibility_definition(&arg, visibility, DefinitionFlags::empty());
             } else {
                 // Unsupported arg — diagnostic + visit for side effects.
                 let arg_offset = Offset::from_prism_location(&arg.location());
@@ -1332,7 +1381,12 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
-    fn create_method_visibility_definition(&mut self, arg: &ruby_prism::Node, visibility: Visibility) {
+    fn create_method_visibility_definition(
+        &mut self,
+        arg: &ruby_prism::Node,
+        visibility: Visibility,
+        flags: DefinitionFlags,
+    ) {
         let (name, location) = match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
@@ -1358,7 +1412,7 @@ impl<'a> RubyIndexer<'a> {
             self.uri_id,
             arg_offset,
             Box::default(),
-            DefinitionFlags::empty(),
+            flags,
             self.current_nesting_definition_id(),
         )));
 
@@ -2052,6 +2106,12 @@ impl Visit<'_> for RubyIndexer<'_> {
             "public_constant" => {
                 self.handle_constant_visibility(node, Visibility::Public);
             }
+            "private_class_method" => {
+                self.handle_singleton_method_visibility(node, Visibility::Private, "private_class_method");
+            }
+            "public_class_method" => {
+                self.handle_singleton_method_visibility(node, Visibility::Public, "public_class_method");
+            }
             _ => {
                 // For method calls that we don't explicitly handle each part, we continue visiting their parts as we
                 // may discover something inside