extract

Author: slbug

docs/ruby-behaviors.md

@@ -968,6 +968,14 @@ class Foo; private :foo; end  # works — retroactive across reopen
 Foo.private_instance_methods(false)  # => [:foo]
 ```
 
+The method must already exist when the visibility call runs. Within one file, `private :foo` before `def foo` matches
+Ruby's `NameError` behavior. Across files, Rubydex cannot know runtime load order, so it treats cross-file definitions
+as potentially available. A definitely-prior same-file definition is preferred for the visibility snapshot; URI lexical
+order is used only as a deterministic tie-breaker when multiple cross-file definitions could apply.
+
+Rubydex treats visibility calls inside method bodies or ordinary blocks as runtime calls. It does not apply those
+visibility effects statically because Ruby only executes them if the containing method or block is called.
+
 **`private :inherited_method` creates an implicit copy:**
 
 ```ruby
@@ -1039,8 +1047,8 @@ Foo.singleton_methods(false)          # => [:foo]
 Ruby can invoke `module_function` indirectly with `send` on a module object. Rubydex indexes the direct call forms above;
 dynamic `send` calls are treated as ordinary method calls rather than visibility operations.
 
-Rubydex also treats `module_function` calls inside method bodies or ordinary blocks as runtime calls. It does not apply
-those visibility effects statically because Ruby only executes them if the containing method or block is called.
+Like other visibility operations, Rubydex treats `module_function` calls inside method bodies or ordinary blocks as
+runtime calls rather than static visibility operations.
 
 **Creates a copy, not a reference:**
 
@@ -1077,8 +1085,9 @@ invalidate and rebuild generated copies when the source file changes, because a
 copy the current source method at the `module_function :foo` call.
 
 When the source method and `module_function :foo` call are in different files, static indexing does not know runtime
-load order. Rubydex uses URI lexical order as a deterministic proxy: methods in earlier URI-sorted files are eligible
-for later URI-sorted visibility calls, while methods in later files are not. Within one file, the source method must
+load order. Rubydex treats cross-file source methods as potentially available and uses URI lexical order only as a
+deterministic tie-breaker when multiple cross-file definitions could be copied. A definitely-prior same-file source
+method is preferred over cross-file candidates. Within one file, the source method must
 appear before the `module_function :foo` call, matching Ruby's `NameError` behavior for calls that appear before the
 method definition.
 
@@ -1135,6 +1144,9 @@ Foo.constants  # => [] (private constants hidden from .constants)
 - `Foo.const_defined?(:PRIV)` returns **true** even for private constants — visibility doesn't affect `const_defined?`
 - `Foo.const_get(:PRIV)` **bypasses** private constant visibility and returns the value — only the `::` operator enforces `private_constant`
 
+Rubydex treats `private_constant`/`public_constant` calls inside method bodies or ordinary blocks as runtime calls rather
+than static visibility operations.
+
 #### `public_constant`
 
 Reverses `private_constant`:

rust/rubydex-sys/src/graph_api.rs

@@ -1001,11 +1001,16 @@ pub unsafe extern "C" fn rdx_graph_visibility(pointer: GraphPointer, declaration
             return ptr::null();
         };
 
+        debug_assert_ne!(
+            visibility,
+            Visibility::ModuleFunction,
+            "module_function visibility must be resolved before C API use"
+        );
+
         let c_visibility = match visibility {
             Visibility::Public => CVisibility::Public,
             Visibility::Protected => CVisibility::Protected,
-            Visibility::Private => CVisibility::Private,
-            Visibility::ModuleFunction => unreachable!("module_function visibility must be resolved before C API use"),
+            Visibility::Private | Visibility::ModuleFunction => CVisibility::Private,
         };
 
         Box::into_raw(Box::new(c_visibility)).cast_const()

rust/rubydex/src/indexing/ruby_indexer.rs

@@ -1230,17 +1230,18 @@ impl<'a> RubyIndexer<'a> {
     }
 
     fn handle_constant_visibility(&mut self, node: &ruby_prism::CallNode, visibility: Visibility) {
+        if self.current_nesting_is_runtime_body() {
+            self.visit_runtime_call_node(node);
+            return;
+        }
+
         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(_)) => {
-                    self.visit_call_node_parts(node);
-                    return;
-                }
                 None => {
                     self.local_graph.add_diagnostic(
                         Rule::InvalidPrivateConstant,
@@ -1319,13 +1320,14 @@ impl<'a> RubyIndexer<'a> {
         visibility: Visibility,
         call_name: &str,
     ) {
+        if self.current_nesting_is_runtime_body() {
+            self.visit_runtime_call_node(node);
+            return;
+        }
+
         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 => {
+            Some(ruby_prism::Node::SelfNode { .. }) | None => {
+                if self.nesting_stack.last().is_none() {
                     self.local_graph.add_diagnostic(
                         Rule::InvalidMethodVisibility,
                         Offset::from_prism_location(&node.location()),
@@ -1334,8 +1336,7 @@ impl<'a> RubyIndexer<'a> {
                     self.visit_call_node_parts(node);
                     return;
                 }
-                _ => {}
-            },
+            }
             _ => {
                 self.visit_call_node_parts(node);
                 return;
@@ -2003,8 +2004,6 @@ impl Visit<'_> for RubyIndexer<'_> {
                 .unwrap_or_else(|| offset_for_comments.start());
 
             Self::each_string_or_symbol_arg(call, |name, location| {
-                let reader_str_id = self.local_graph.intern_string(format!("{name}()"));
-                let writer_str_id = self.local_graph.intern_string(format!("{name}=()"));
                 let parent_nesting_id = self.parent_nesting_id();
                 let offset = Offset::from_prism_location(&location);
 
@@ -2018,6 +2017,9 @@ impl Visit<'_> for RubyIndexer<'_> {
 
                 match kind {
                     AttrKind::Accessor => {
+                        let reader_str_id = self.local_graph.intern_string(format!("{name}()"));
+                        let writer_str_id = self.local_graph.intern_string(format!("{name}=()"));
+
                         let reader = Definition::AttrAccessor(Box::new(AttrAccessorDefinition::new(
                             reader_str_id,
                             self.uri_id,
@@ -2043,6 +2045,8 @@ impl Visit<'_> for RubyIndexer<'_> {
                         self.add_member_to_current_owner(writer_id);
                     }
                     AttrKind::Reader => {
+                        let reader_str_id = self.local_graph.intern_string(format!("{name}()"));
+
                         let definition = Definition::AttrReader(Box::new(AttrReaderDefinition::new(
                             reader_str_id,
                             self.uri_id,
@@ -2056,6 +2060,8 @@ impl Visit<'_> for RubyIndexer<'_> {
                         self.add_member_to_current_owner(definition_id);
                     }
                     AttrKind::Writer => {
+                        let writer_str_id = self.local_graph.intern_string(format!("{name}=()"));
+
                         let definition = Definition::AttrWriter(Box::new(AttrWriterDefinition::new(
                             writer_str_id,
                             self.uri_id,
@@ -2199,7 +2205,7 @@ impl Visit<'_> for RubyIndexer<'_> {
             "private" | "protected" | "public" | "module_function" => {
                 let visibility = Visibility::from_string(message.as_str());
 
-                if visibility == Visibility::ModuleFunction && self.current_nesting_is_runtime_body() {
+                if self.current_nesting_is_runtime_body() {
                     self.visit_runtime_call_node(node);
                     return;
                 }

rust/rubydex/src/model/declaration.rs

@@ -425,7 +425,6 @@ impl Declaration {
             if let Some(pos) = it.definition_ids.iter().position(|id| id == definition_id) {
                 // Definition order is semantic for retroactive visibility; keep it stable.
                 it.definition_ids.remove(pos);
-                it.definition_ids.shrink_to_fit();
                 true
             } else {
                 false

rust/rubydex/src/model/definitions.rs

@@ -195,6 +195,41 @@ impl Definition {
     pub fn is_deprecated(&self) -> bool {
         all_definitions!(self, it => it.flags().is_deprecated())
     }
+
+    #[must_use]
+    pub fn method_effective_visibility(&self) -> Option<Visibility> {
+        match self {
+            Definition::MethodVisibility(vis) => Some(match vis.visibility() {
+                Visibility::ModuleFunction => Visibility::Private,
+                visibility => *visibility,
+            }),
+            Definition::Method(method) => Some(*method.visibility()),
+            Definition::AttrAccessor(attr) => Some(*attr.visibility()),
+            Definition::AttrReader(attr) => Some(*attr.visibility()),
+            Definition::AttrWriter(attr) => Some(*attr.visibility()),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub(crate) fn establishes_method_member(&self) -> bool {
+        matches!(
+            self,
+            Definition::Method(_)
+                | Definition::MethodAlias(_)
+                | Definition::AttrAccessor(_)
+                | Definition::AttrReader(_)
+                | Definition::AttrWriter(_)
+        )
+    }
+
+    #[must_use]
+    pub(crate) fn is_copyable_method_body(&self) -> bool {
+        matches!(
+            self,
+            Definition::Method(_) | Definition::AttrAccessor(_) | Definition::AttrReader(_) | Definition::AttrWriter(_)
+        )
+    }
 }
 
 /// Represents a mixin: include, prepend, or extend.
@@ -1121,7 +1156,12 @@ impl ParameterStruct {
     }
 }
 
-/// An attr accessor definition
+/// The reader-side method definition created by `attr_accessor`.
+///
+/// The writer side is indexed separately as an `AttrWriterDefinition` for the
+/// generated `foo=()` method. Keeping the reader and writer as separate method
+/// declarations lets visibility changes and `module_function :foo=` target the
+/// same methods Ruby creates.
 ///
 /// # Example
 /// ```ruby

rust/rubydex/src/model/document.rs

@@ -82,6 +82,13 @@ impl Document {
         self.diagnostics.push(diagnostic);
     }
 
+    pub fn retain_diagnostics<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&Diagnostic) -> bool,
+    {
+        self.diagnostics.retain(|diagnostic| f(diagnostic));
+    }
+
     /// Computes the require path for this document given load paths.
     ///
     /// Returns `None` if: