rubydex 0.2.9 → 0.4.0

data/rust/rubydex/src/diagnostic.rs

@@ -1,6 +1,6 @@
 #[cfg(any(test, feature = "test_utils"))]
 use crate::model::document::Document;
-use crate::{model::ids::UriId, offset::Offset};
+use crate::{assert_mem_size, model::ids::UriId, offset::Offset};
 
 #[derive(Debug)]
 pub struct Diagnostic {
@@ -9,6 +9,7 @@ pub struct Diagnostic {
     offset: Offset,
     message: String,
 }
+assert_mem_size!(Diagnostic, 48);
 
 impl Diagnostic {
     #[must_use]
@@ -53,60 +54,85 @@ impl Diagnostic {
     }
 }
 
-fn camel_to_snake(s: &str) -> String {
-    let mut snake = String::new();
-    for (i, ch) in s.chars().enumerate() {
-        if ch.is_uppercase() {
-            if i != 0 {
-                snake.push('-');
-            }
-            for lc in ch.to_lowercase() {
-                snake.push(lc);
-            }
-        } else {
-            snake.push(ch);
-        }
-    }
-    snake
+#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Severity {
+    Error,
+    Warning,
+    Information,
+    Hint,
 }
 
 macro_rules! rules {
-    (
-        $( $variant:ident );* $(;)?
-    ) => {
+    ($($(#[$attribute:meta])* $rule:ident),+ $(,)?) => {
         #[derive(Debug, Copy, Clone, PartialEq, Eq)]
         pub enum Rule {
-            $(
-                $variant,
-            )*
+            $($(#[$attribute])* $rule,)+
         }
 
-        impl std::fmt::Display for Rule {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(f, "{}", match self {
-                    $(
-                        Rule::$variant => camel_to_snake(stringify!($variant)),
-                    )*
-                })
+        impl Rule {
+            #[must_use]
+            pub fn all() -> &'static [Self] {
+                &[$(Self::$rule,)+]
             }
         }
-    }
+    };
 }
 
 rules! {
     // Parsing
-    ParseError;
-    ParseWarning;
+    ParseError,
+    ParseWarning,
 
     // Indexing
-    DynamicConstantReference;
-    DynamicSingletonDefinition;
-    DynamicAncestor;
-    TopLevelMixinSelf;
-    InvalidPrivateConstant;
-    InvalidMethodVisibility;
+    DynamicConstantReference,
+    DynamicSingletonDefinition,
+    DynamicAncestor,
+    TopLevelMixinSelf,
+    InvalidConstantVisibility,
+    InvalidMethodVisibility,
 
     // Resolution
-    UndefinedMethodVisibilityTarget;
-    UndefinedConstantVisibilityTarget;
+    UndefinedMethodVisibilityTarget,
+    UndefinedConstantVisibilityTarget,
+}
+
+impl Rule {
+    #[must_use]
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::ParseError => "ParseError",
+            Self::ParseWarning => "ParseWarning",
+            Self::DynamicConstantReference => "DynamicConstantReference",
+            Self::DynamicSingletonDefinition => "DynamicSingletonDefinition",
+            Self::DynamicAncestor => "DynamicAncestor",
+            Self::TopLevelMixinSelf => "TopLevelMixinSelf",
+            Self::InvalidConstantVisibility => "InvalidConstantVisibility",
+            Self::InvalidMethodVisibility => "InvalidMethodVisibility",
+            Self::UndefinedMethodVisibilityTarget => "UndefinedMethodVisibilityTarget",
+            Self::UndefinedConstantVisibilityTarget => "UndefinedConstantVisibilityTarget",
+        }
+    }
+
+    #[must_use]
+    pub fn default_severity(&self) -> Severity {
+        match self {
+            Self::ParseError => Severity::Error,
+            Self::ParseWarning
+            | Self::InvalidConstantVisibility
+            | Self::InvalidMethodVisibility
+            | Self::UndefinedMethodVisibilityTarget
+            | Self::UndefinedConstantVisibilityTarget => Severity::Warning,
+            Self::DynamicConstantReference
+            | Self::DynamicSingletonDefinition
+            | Self::DynamicAncestor
+            | Self::TopLevelMixinSelf => Severity::Information,
+        }
+    }
+}
+
+impl std::fmt::Display for Rule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name())
+    }
 }

data/rust/rubydex/src/errors.rs

@@ -26,5 +26,4 @@ macro_rules! errors {
 errors!(
     FileError;
     ConfigError;
-    ConfigNotFound;
 );

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

@@ -6,7 +6,7 @@ use crate::model::document::Document;
 use crate::model::graph::NameDependent;
 use crate::model::identity_maps::IdentityHashMap;
 use crate::model::ids::{ConstantReferenceId, DefinitionId, MethodReferenceId, NameId, StringId, UriId};
-use crate::model::name::{Name, NameRef};
+use crate::model::name::{Name, NameRef, ParentScope};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
 use crate::offset::Offset;
@@ -119,7 +119,8 @@ impl LocalGraph {
         &self.names
     }
 
-    pub fn add_name(&mut self, name: Name) -> NameId {
+    pub fn add_name(&mut self, str: StringId, parent_scope: ParentScope, nesting: Option<NameId>) -> NameId {
+        let name = Name::new(&self.names, str, parent_scope, nesting);
         let name_id = name.id();
 
         match self.names.entry(name_id) {
@@ -128,13 +129,13 @@ impl LocalGraph {
                 entry.get_mut().increment_ref_count(1);
             }
             Entry::Vacant(entry) => {
-                if let Some(&parent_scope) = name.parent_scope().as_ref() {
+                if let Some(&parent_scope_id) = parent_scope.as_ref() {
                     self.name_dependents
-                        .entry(parent_scope)
+                        .entry(parent_scope_id)
                         .or_default()
                         .push(NameDependent::ChildName(name_id));
                 }
-                if let Some(&nesting_id) = name.nesting().as_ref() {
+                if let Some(nesting_id) = nesting {
                     self.name_dependents
                         .entry(nesting_id)
                         .or_default()

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

@@ -3,8 +3,9 @@
 use core::panic;
 
 use ruby_rbs::node::{
-    self, AliasKind, ClassNode, CommentNode, ConstantNode, ExtendNode, FunctionTypeNode, GlobalNode, IncludeNode,
-    ModuleNode, Node, NodeList, PrependNode, TypeNameNode, Visit,
+    self, AliasKind, AttrAccessorNode, AttrReaderNode, AttrWriterNode, AttributeKind, AttributeVisibility, ClassNode,
+    CommentNode, ConstantNode, ExtendNode, FunctionTypeNode, GlobalNode, IncludeNode, ModuleNode, Node, NodeList,
+    PrependNode, TypeNameNode, Visit,
 };
 
 use crate::diagnostic::Rule;
@@ -17,7 +18,7 @@ use crate::model::definitions::{
 };
 use crate::model::document::Document;
 use crate::model::ids::{ConstantReferenceId, DefinitionId, NameId, StringId, UriId};
-use crate::model::name::{Name, ParentScope};
+use crate::model::name::ParentScope;
 use crate::model::references::ConstantReference;
 use crate::model::visibility::Visibility;
 use crate::offset::Offset;
@@ -80,7 +81,16 @@ impl<'a> RBSIndexer<'a> {
             let Node::Symbol(symbol) = path_node else {
                 continue;
             };
-            parent_scope = ParentScope::Some(self.intern_name(&symbol, parent_scope, nesting_name_id));
+            let name_id = self.intern_name(&symbol, parent_scope, nesting_name_id);
+
+            // Emit a constant reference for each parent-scope segment so it gets its own resolution
+            // unit, mirroring the Ruby indexer (see `index_constant_reference`). Otherwise the
+            // parent scope is an orphan name that never resolves, leaving qualified references stuck.
+            let offset = Offset::from_rbs_location(&symbol.location());
+            self.local_graph
+                .add_constant_reference(ConstantReference::new(name_id, self.uri_id, offset));
+
+            parent_scope = ParentScope::Some(name_id);
         }
 
         self.intern_name(&type_name.name(), parent_scope, nesting_name_id)
@@ -93,8 +103,7 @@ impl<'a> RBSIndexer<'a> {
         nesting_name_id: Option<NameId>,
     ) -> NameId {
         let string_id = self.local_graph.intern_string(symbol.as_str().to_owned());
-        self.local_graph
-            .add_name(Name::new(string_id, parent_scope, nesting_name_id))
+        self.local_graph.add_name(string_id, parent_scope, nesting_name_id)
     }
 
     fn parent_lexical_scope_id(&self) -> Option<DefinitionId> {
@@ -214,6 +223,133 @@ impl<'a> RBSIndexer<'a> {
         definition_id
     }
 
+    #[allow(clippy::too_many_arguments)]
+    fn register_attribute_methods(
+        &mut self,
+        name: &str,
+        offset: Offset,
+        name_offset: Offset,
+        comments: Box<[Comment]>,
+        flags: DefinitionFlags,
+        lexical_nesting_id: Option<DefinitionId>,
+        kind: AttributeKind,
+        attribute_visibility: AttributeVisibility,
+        reader: bool,
+        writer: bool,
+    ) {
+        let (visibility, receiver) = match kind {
+            AttributeKind::Instance => {
+                let visibility = match attribute_visibility {
+                    AttributeVisibility::Public => Visibility::Public,
+                    AttributeVisibility::Private => Visibility::Private,
+                    AttributeVisibility::Unspecified => self.current_visibility,
+                };
+                (visibility, None)
+            }
+            AttributeKind::Singleton => {
+                let visibility = match attribute_visibility {
+                    AttributeVisibility::Private => Visibility::Private,
+                    AttributeVisibility::Public | AttributeVisibility::Unspecified => Visibility::Public,
+                };
+                (
+                    visibility,
+                    Some(Receiver::SelfReceiver(
+                        lexical_nesting_id.expect("Singleton attribute must have a lexical enclosing scope"),
+                    )),
+                )
+            }
+        };
+
+        match (reader, writer) {
+            (true, true) => {
+                self.register_attribute_method(
+                    name,
+                    false,
+                    offset.clone(),
+                    name_offset.clone(),
+                    comments.clone(),
+                    flags.clone(),
+                    lexical_nesting_id,
+                    visibility,
+                    receiver.clone(),
+                );
+                self.register_attribute_method(
+                    name,
+                    true,
+                    offset,
+                    name_offset,
+                    comments,
+                    flags,
+                    lexical_nesting_id,
+                    visibility,
+                    receiver,
+                );
+            }
+            (true, false) => self.register_attribute_method(
+                name,
+                false,
+                offset,
+                name_offset,
+                comments,
+                flags,
+                lexical_nesting_id,
+                visibility,
+                receiver,
+            ),
+            (false, true) => self.register_attribute_method(
+                name,
+                true,
+                offset,
+                name_offset,
+                comments,
+                flags,
+                lexical_nesting_id,
+                visibility,
+                receiver,
+            ),
+            (false, false) => unreachable!("attribute must have a reader or writer"),
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn register_attribute_method(
+        &mut self,
+        name: &str,
+        writer: bool,
+        offset: Offset,
+        name_offset: Offset,
+        comments: Box<[Comment]>,
+        flags: DefinitionFlags,
+        lexical_nesting_id: Option<DefinitionId>,
+        visibility: Visibility,
+        receiver: Option<Receiver>,
+    ) {
+        let str_id = self
+            .local_graph
+            .intern_string(format!("{name}{}()", if writer { "=" } else { "" }));
+        let signatures = if writer {
+            let parameter_name = self.local_graph.intern_string(name.to_owned());
+            let parameter = Parameter::RequiredPositional(ParameterStruct::new(name_offset.clone(), parameter_name));
+            Signatures::Simple(vec![parameter].into_boxed_slice())
+        } else {
+            Signatures::Simple(Box::new([]))
+        };
+
+        let definition = Definition::Method(Box::new(MethodDefinition::new(
+            str_id,
+            self.uri_id,
+            offset,
+            name_offset,
+            comments,
+            flags,
+            lexical_nesting_id,
+            signatures,
+            visibility,
+            receiver,
+        )));
+        self.register_definition(definition, lexical_nesting_id);
+    }
+
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn source_at(&self, location: &node::RBSLocationRange) -> String {
         let start = location.start() as usize;
@@ -486,7 +622,10 @@ impl Visit for RBSIndexer<'_> {
             self.uri_id,
             offset,
             comments,
-            Self::flags(&constant_node.annotations()),
+            // RBS establishes that the constant exists, but its value type is intentionally not
+            // represented in the graph. Treat it like a dynamic Ruby assignment so resolution
+            // may promote it when a namespace or singleton receiver is required.
+            Self::flags(&constant_node.annotations()) | DefinitionFlags::PROMOTABLE,
             lexical_nesting_id,
         )));
 
@@ -562,6 +701,51 @@ impl Visit for RBSIndexer<'_> {
         self.register_definition(definition, lexical_nesting_id);
     }
 
+    fn visit_attr_reader_node(&mut self, attribute_node: &AttrReaderNode) {
+        self.register_attribute_methods(
+            attribute_node.name().as_str(),
+            Offset::from_rbs_location(&attribute_node.location()),
+            Offset::from_rbs_location(&attribute_node.name_location()),
+            self.collect_comments(attribute_node.comment()),
+            Self::flags(&attribute_node.annotations()),
+            self.parent_lexical_scope_id(),
+            attribute_node.kind(),
+            attribute_node.visibility(),
+            true,
+            false,
+        );
+    }
+
+    fn visit_attr_writer_node(&mut self, attribute_node: &AttrWriterNode) {
+        self.register_attribute_methods(
+            attribute_node.name().as_str(),
+            Offset::from_rbs_location(&attribute_node.location()),
+            Offset::from_rbs_location(&attribute_node.name_location()),
+            self.collect_comments(attribute_node.comment()),
+            Self::flags(&attribute_node.annotations()),
+            self.parent_lexical_scope_id(),
+            attribute_node.kind(),
+            attribute_node.visibility(),
+            false,
+            true,
+        );
+    }
+
+    fn visit_attr_accessor_node(&mut self, attribute_node: &AttrAccessorNode) {
+        self.register_attribute_methods(
+            attribute_node.name().as_str(),
+            Offset::from_rbs_location(&attribute_node.location()),
+            Offset::from_rbs_location(&attribute_node.name_location()),
+            self.collect_comments(attribute_node.comment()),
+            Self::flags(&attribute_node.annotations()),
+            self.parent_lexical_scope_id(),
+            attribute_node.kind(),
+            attribute_node.visibility(),
+            true,
+            true,
+        );
+    }
+
     fn visit_method_definition_node(&mut self, def_node: &node::MethodDefinitionNode) {
         let str_id = self.local_graph.intern_string(format!("{}()", def_node.name()));
         let offset = Offset::from_rbs_location(&def_node.location());
@@ -639,6 +823,7 @@ impl Visit for RBSIndexer<'_> {
 mod tests {
     use ruby_rbs::node::{self, Node, NodeList};
 
+    use crate::diagnostic::Severity;
     use crate::indexing::rbs_indexer::RBSIndexer;
     use crate::model::definitions::{Definition, DefinitionFlags, Parameter, Signatures};
     use crate::model::visibility::Visibility;
@@ -670,7 +855,11 @@ mod tests {
     fn index_source_with_errors() {
         let context = index_source("module");
 
-        assert_local_diagnostics_eq!(&context, ["parse-error: Failed to parse RBS document (1:1-1:1)"]);
+        assert_local_diagnostics_eq!(
+            &context,
+            ["ParseError: Failed to parse RBS document (1:1-1:1)"],
+            severity: Severity::Error
+        );
 
         assert!(context.graph().definitions().is_empty());
     }
@@ -1039,6 +1228,93 @@ mod tests {
         });
     }
 
+    #[test]
+    fn indexes_attribute_members_as_methods_without_retaining_types_or_instance_variables() {
+        let context = index_source({
+            "
+            class Foo
+              # Reader documentation
+              %a{deprecated}
+              attr_reader inferred: Integer
+              attr_reader absent(): Symbol
+              attr_writer explicit (@writer): String
+              attr_accessor accessor: bool
+              private
+              attr_reader inherited_visibility: Float
+              public
+              private attr_accessor self.class_value (@class_value): bool
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 9);
+
+        let method = |name: &str| {
+            context
+                .graph()
+                .definitions()
+                .values()
+                .find_map(|definition| match definition {
+                    Definition::Method(method)
+                        if context
+                            .graph()
+                            .strings()
+                            .get(method.str_id())
+                            .is_some_and(|string| string.as_str() == name) =>
+                    {
+                        Some(method)
+                    }
+                    _ => None,
+                })
+                .unwrap_or_else(|| panic!("expected `{name}` method definition"))
+        };
+
+        for name in [
+            "inferred()",
+            "absent()",
+            "explicit=()",
+            "accessor()",
+            "accessor=()",
+            "inherited_visibility()",
+            "class_value()",
+            "class_value=()",
+        ] {
+            assert_eq!(method(name).signatures().as_slice().len(), 1);
+        }
+
+        for name in [
+            "inferred()",
+            "absent()",
+            "accessor()",
+            "inherited_visibility()",
+            "class_value()",
+        ] {
+            assert!(method(name).signatures().as_slice()[0].is_empty());
+        }
+
+        for (name, parameter_name) in [
+            ("explicit=()", "explicit"),
+            ("accessor=()", "accessor"),
+            ("class_value=()", "class_value"),
+        ] {
+            let signature = &method(name).signatures().as_slice()[0];
+            let [Parameter::RequiredPositional(parameter)] = signature.as_ref() else {
+                panic!("expected `{name}` to have one required positional parameter");
+            };
+            assert_string_eq!(&context, parameter.str(), parameter_name);
+            assert_offset_string!(&context, parameter.offset(), parameter_name);
+        }
+
+        assert_eq!(method("class_value()").visibility(), &Visibility::Private);
+        assert_eq!(method("class_value=()").visibility(), &Visibility::Private);
+        assert_eq!(method("inherited_visibility()").visibility(), &Visibility::Private);
+        assert_method_has_receiver!(&context, method("class_value()"), "Foo");
+        assert_method_has_receiver!(&context, method("class_value=()"), "Foo");
+        assert_def_comments_eq!(&context, method("inferred()"), ["# Reader documentation"]);
+        assert!(method("inferred()").flags().contains(DefinitionFlags::DEPRECATED));
+    }
+
     #[test]
     fn index_alias_node() {
         let context = index_source({