rubydex 0.3.0 → 0.4.1

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,176 @@ 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 );* $(;)?
-    ) => {
+    ($($(#[doc = $documentation:literal])+ $rule:ident => $severity:ident),+ $(,)?) => {
         #[derive(Debug, Copy, Clone, PartialEq, Eq)]
         pub enum Rule {
-            $(
-                $variant,
-            )*
+            $($(#[doc = $documentation])+ $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,)+]
+            }
+
+            #[must_use]
+            pub fn name(&self) -> &'static str {
+                match self {
+                    $(Self::$rule => stringify!($rule),)+
+                }
+            }
+
+            #[must_use]
+            pub fn default_severity(&self) -> Severity {
+                match self {
+                    $(Self::$rule => Severity::$severity,)+
+                }
+            }
+
+            #[must_use]
+            pub fn documentation(&self) -> &'static [&'static str] {
+                match self {
+                    $(Self::$rule => &[$($documentation,)+],)+
+                }
             }
         }
-    }
+    };
 }
 
 rules! {
-    // Parsing
-    ParseError;
-    ParseWarning;
-
-    // Indexing
-    DynamicConstantReference;
-    DynamicSingletonDefinition;
-    DynamicAncestor;
-    TopLevelMixinSelf;
-    InvalidConstantVisibility;
-    InvalidMethodVisibility;
-
-    // Resolution
-    UndefinedMethodVisibilityTarget;
-    UndefinedConstantVisibilityTarget;
+    // ******** Parsing ******** //
+
+    /// A parse error represents invalid Ruby syntax and a program that will fail to execute. For example, a missing
+    /// `end`, an unterminated string, a missing parenthesis.
+    ///
+    /// ```ruby
+    /// class Foo
+    /// ^^^^^ Syntax error. Missing end token
+    /// ```
+    ParseError => Error,
+
+    /// Parse warnings represent code that has valid syntax, but may not do what the developer expects. For example,
+    /// local variables that are completely unused or usage in a void context (creating a line of code that does
+    /// nothing).
+    ///
+    /// ```ruby
+    /// CONST = 1
+    /// CONST
+    /// ^^^^^ Constant used in void context (the expression does nothing).
+    /// puts CONST + 2
+    /// ```
+    ParseWarning => Warning,
+
+    // ******** Indexing ******** //
+
+    /// Dynamic constant references cannot be reasoned about statically because they depend on runtime values. The
+    /// program may still be valid, but the quality of the analysis degrades.
+    ///
+    /// ```ruby
+    /// var::Foo
+    /// ^^^^^^^^ Dynamic constant reference. This might be correct, but it cannot be understood by the analysis.
+    /// ```
+    DynamicConstantReference => Information,
+
+    /// Dynamic singleton targets cannot be reasoned about statically because they depend on runtime values. The program
+    /// may still be valid, but the quality of the analysis degrades.
+    ///
+    /// ```ruby
+    /// class << var
+    ///          ^^^ Dynamic singleton target. This might be correct, but it cannot be understood by the analysis.
+    /// end
+    ///
+    /// def var.bar
+    ///     ^^^ Dynamic singleton target.
+    /// end
+    /// ```
+    DynamicSingletonDefinition => Information,
+
+    /// Dynamic ancestor references cannot be reasoned about statically because they depend on runtime values. The
+    /// program may still be valid, but the quality of the analysis degrades. In the case of ancestors, since they
+    /// influence constant resolution, the degradation may be more impactful than other dynamic references.
+    ///
+    /// ```ruby
+    /// class Foo < var
+    ///             ^^^ Dynamic ancestor reference. This might be correct, but it cannot be understood by the analysis.
+    ///   include SomeClass.method_call
+    ///           ^^^^^^^^^^^^^^^^^^^^^ Dynamic ancestor reference.
+    /// end
+    /// ```
+    DynamicAncestor => Information,
+
+    /// The top level of a Ruby program is the special <main> object. It is not possible to use `include self` or
+    /// `extend self` on that object.
+    ///
+    /// ```ruby
+    /// include self
+    ///         ^^^^ Cannot include self at the top level
+    /// extend self
+    ///        ^^^^ Cannot extend self at the top level
+    /// ```
+    TopLevelMixinSelf => Information,
+
+    /// Constant visibility operations that depend on dynamic values cannot be reasoned about statically because they
+    /// depend on runtime values. The program may still be valid, but the quality of the analysis degrades.
+    ///
+    /// ```ruby
+    /// var.private_constant :Foo
+    /// ^^^ Invalid constant visibility. This might be correct, but it cannot be understood by the analysis.
+    ///
+    /// private_constant(var)
+    ///                  ^^^ Invalid constant visibility.
+    /// ```
+    InvalidConstantVisibility => Warning,
+
+    /// Method visibility operations that depend on dynamic values cannot be reasoned about statically because they
+    /// depend on runtime values. The program may still be valid, but the quality of the analysis degrades.
+    ///
+    /// ```ruby
+    /// var.private :foo
+    /// ^^^ Invalid method visibility. This might be correct, but it cannot be understood by the analysis.
+    ///
+    /// private(var)
+    ///         ^^^ Invalid method visibility.
+    /// ```
+    InvalidMethodVisibility => Warning,
+
+    // ******** Resolution ******** //
+
+    /// Undefined method visibility target means the analysis couldn't find the definition for the method the code is
+    /// attempting to change visibility of. It could be defined through meta-programming or it indeed does not exist.
+    ///
+    /// ```ruby
+    /// class Foo
+    ///   private :bar
+    ///            ^^^ Undefined method visibility target. The method `bar` is not defined.
+    /// end
+    /// ```
+    UndefinedMethodVisibilityTarget => Warning,
+
+    /// Undefined constant visibility target means the analysis couldn't find the definition for the constant the code is
+    /// attempting to change visibility of. It could be defined through meta-programming or it indeed does not exist.
+    ///
+    /// ```ruby
+    /// class Foo
+    ///   private_constant :Bar
+    ///                    ^^^ Undefined constant visibility target. The constant `Bar` is not defined.
+    /// end
+    /// ```
+    UndefinedConstantVisibilityTarget => Warning,
+}
+
+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;
@@ -102,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> {
@@ -223,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;
@@ -574,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());
@@ -651,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;
@@ -682,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());
     }
@@ -1051,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({

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

@@ -12,7 +12,7 @@ use crate::model::definitions::{
 };
 use crate::model::document::Document;
 use crate::model::ids::{DefinitionId, NameId, StringId, UriId};
-use crate::model::name::{Name, ParentScope};
+use crate::model::name::ParentScope;
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::visibility::Visibility;
 use crate::offset::Offset;
@@ -482,11 +482,9 @@ impl<'a> RubyIndexer<'a> {
         let offset = Offset::from_prism_location(&location);
         let name = Self::location_to_string(&location);
         let string_id = self.local_graph.intern_string(name);
-        let name_id = self.local_graph.add_name(Name::new(
-            string_id,
-            parent_scope_id,
-            self.current_lexical_scope_name_id(),
-        ));
+        let name_id = self
+            .local_graph
+            .add_name(string_id, parent_scope_id, self.current_lexical_scope_name_id());
 
         if push_final_reference {
             self.local_graph
@@ -687,7 +685,7 @@ impl<'a> RubyIndexer<'a> {
                 .intern_string(format!("{}:{}<anonymous>", self.uri_id, offset.start()));
 
             (
-                Some(self.local_graph.add_name(Name::new(string_id, ParentScope::None, None))),
+                Some(self.local_graph.add_name(string_id, ParentScope::None, None)),
                 offset.clone(),
             )
         };
@@ -748,7 +746,7 @@ impl<'a> RubyIndexer<'a> {
                 .intern_string(format!("{}:{}<anonymous>", self.uri_id, offset.start()));
 
             (
-                Some(self.local_graph.add_name(Name::new(string_id, ParentScope::None, None))),
+                Some(self.local_graph.add_name(string_id, ParentScope::None, None)),
                 offset.clone(),
             )
         };
@@ -969,7 +967,7 @@ impl<'a> RubyIndexer<'a> {
                     }
 
                     Some((
-                        self.current_lexical_scope_name_id().unwrap(),
+                        self.current_owner_name_id().unwrap(),
                         Offset::from_prism_location(&arg.location()),
                     ))
                 } else if let Some(name_id) = self.index_constant_reference(&arg, false) {
@@ -1125,7 +1123,7 @@ impl<'a> RubyIndexer<'a> {
                     }
                     None => {
                         let str_id = self.local_graph.intern_string("Object".into());
-                        Some(self.local_graph.add_name(Name::new(str_id, ParentScope::None, None)))
+                        Some(self.local_graph.add_name(str_id, ParentScope::None, None))
                     }
                 }
             }
@@ -1169,7 +1167,7 @@ impl<'a> RubyIndexer<'a> {
         let string_id = self.local_graph.intern_string(singleton_class_name);
         let new_name_id = self
             .local_graph
-            .add_name(Name::new(string_id, ParentScope::Attached(name_id), None));
+            .add_name(string_id, ParentScope::Attached(name_id), None);
 
         let location = receiver.map_or(fallback_location, ruby_prism::Node::location);
         let offset = Offset::from_prism_location(&location);
@@ -1650,7 +1648,7 @@ impl Visit<'_> for RubyIndexer<'_> {
         let nesting = self.current_lexical_scope_name_id();
         let name_id = self
             .local_graph
-            .add_name(Name::new(string_id, ParentScope::Attached(attached_target), nesting));
+            .add_name(string_id, ParentScope::Attached(attached_target), nesting);
 
         let definition = Definition::SingletonClass(Box::new(SingletonClassDefinition::new(
             name_id,