rubydex 0.4.0 → 0.4.2

data/rust/Cargo.lock

@@ -99,7 +99,7 @@ dependencies = [
  "quote",
  "regex",
  "rustc-hash",
- "shlex",
+ "shlex 1.3.0",
  "syn",
 ]
 
@@ -151,7 +151,7 @@ version = "1.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
 dependencies = [
- "shlex",
+ "shlex 1.3.0",
 ]
 
 [[package]]
@@ -718,9 +718,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "ruby-prism"
-version = "1.9.0"
+version = "2.0.0-rc.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b302f00359d0b5423a600314935ca5f994484e15da2db5345631d28c6e029d6"
+checksum = "6d34b0f30ca0b7233a454827204ee7dc1a70d8faa3a26eae95f09ada5386757c"
 dependencies = [
  "ruby-prism-sys",
  "serde",
@@ -729,12 +729,12 @@ dependencies = [
 
 [[package]]
 name = "ruby-prism-sys"
-version = "1.9.0"
+version = "2.0.0-rc.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f85fd9571455bdca2b3bf0b2f543cd13ac39d5de0026a8eb2deb94ffd264f00"
+checksum = "f0e59b94e20c878bb618a355abd00724ad1eb4514341936c6668bea987437a29"
 dependencies = [
- "bindgen",
  "cc",
+ "shlex 2.0.1",
 ]
 
 [[package]]
@@ -760,7 +760,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex"
-version = "0.2.6"
+version = "0.4.2"
 dependencies = [
  "assert_cmd",
  "bitflags",
@@ -789,7 +789,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex-sys"
-version = "0.2.6"
+version = "0.4.2"
 dependencies = [
  "cbindgen",
  "libc",
@@ -902,6 +902,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -1326,9 +1332,9 @@ checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
 
 [[package]]
 name = "xxhash-rust"
-version = "0.8.15"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
+checksum = "4d93c89cdc2d3a63c3ec48ffe926931bdc069eafa8e4402fe6d8f790c9d1e576"
 
 [[package]]
 name = "yoke"

data/rust/Cargo.toml

@@ -6,6 +6,9 @@ members = [
 
 resolver = "3"
 
+[workspace.package]
+version = "0.4.2"
+
 [profile.release]
 lto = true
 opt-level = 3

data/rust/rubydex/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rubydex"
-version = "0.2.6"
+version.workspace = true
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
@@ -15,6 +15,10 @@ categories = ["development-tools"]
 name = "rubydex_cli"
 path = "src/main.rs"
 
+[[bin]]
+name = "generate_ruby_rules"
+path = "src/bin/generate_ruby_rules.rs"
+
 [lib]
 crate-type = ["rlib"]
 
@@ -28,7 +32,7 @@ test_utils = ["dep:tempfile"]
 
 [dependencies]
 cypher-parser = "0.8.1"
-ruby-prism = "1.9.0"
+ruby-prism = "2.0.0-rc.2"
 ruby-rbs = "0.3"
 url = "2.5.4"
 xxhash-rust = { version = "0.8.15", features = ["xxh3"] }

data/rust/rubydex/src/bin/generate_ruby_rules.rs

@@ -0,0 +1,94 @@
+use rubydex::diagnostic::{Rule, Severity};
+use std::collections::HashSet;
+use std::path::Path;
+use std::{env, fs};
+
+// Takes the built-in diagnostic rules and generates Ruby classes for them in `lib/rubydex/rules`.
+fn main() {
+    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("..").join("..");
+    let directory = root.join("lib").join("rubydex").join("rules");
+    let mut generated_files = HashSet::new();
+
+    for rule in Rule::all().iter().copied() {
+        write_rule(&directory, rule, &mut generated_files);
+    }
+
+    // Remove stale rules
+    for entry in fs::read_dir(&directory).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+
+        if path.is_file() {
+            let file_name = path.file_name().unwrap().to_string_lossy();
+
+            if !generated_files.contains(&file_name.to_string()) {
+                fs::remove_file(path).unwrap();
+            }
+        }
+    }
+}
+
+fn write_rule(dir: &Path, rule: Rule, generated_files: &mut HashSet<String>) {
+    let documentation = rule
+        .documentation()
+        .iter()
+        .map(|line| format!("    #{line}").trim_end().to_owned())
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    let contents = format!(
+        "# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+{documentation}
+    class {name} < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          {severity}
+        end
+      end
+    end
+  end
+end
+",
+        name = rule.name(),
+        severity = to_ruby_severity(rule.default_severity()),
+    );
+
+    let file_name = format!("{}.rb", snake_case(rule.name()));
+    fs::write(dir.join(&file_name), contents).unwrap();
+    generated_files.insert(file_name);
+}
+
+fn to_ruby_severity(severity: Severity) -> &'static str {
+    match severity {
+        Severity::Error => "Severity::Error",
+        Severity::Warning => "Severity::Warning",
+        Severity::Information => "Severity::Information",
+        Severity::Hint => "Severity::Hint",
+    }
+}
+
+fn snake_case(name: &str) -> String {
+    let mut result = String::with_capacity(name.len() + 4);
+
+    for (index, character) in name.char_indices() {
+        if character.is_uppercase() {
+            if index != 0 {
+                result.push('_');
+            }
+
+            result.extend(character.to_lowercase());
+        } else {
+            result.push(character);
+        }
+    }
+
+    result
+}

data/rust/rubydex/src/compile_assertions.rs

@@ -3,11 +3,13 @@
 macro_rules! assert_mem_size {
     ($struct:ident, $size:expr) => {
         // Check struct name on this assert! error
+        #[cfg(target_pointer_width = "64")]
         const _: () = assert!(
             std::mem::size_of::<$struct>() == $size,
             concat!("Incorrect size for `", stringify!($struct), "`")
         );
         // Check actual size on this array error
+        #[cfg(target_pointer_width = "64")]
         const _: [(); $size] = [(); std::mem::size_of::<$struct>()];
     };
 }

data/rust/rubydex/src/config.rs

@@ -433,7 +433,7 @@ mod tests {
 
         let other = rules.iter().find(|rule| rule.name() == "Other").unwrap();
         assert!(!other.enabled());
-        assert!(other.exclude_patterns().is_empty());
+        assert_eq!(other.exclude_patterns(), []);
         assert_eq!(other.severity(), None);
     }
 

data/rust/rubydex/src/diagnostic.rs

@@ -64,10 +64,10 @@ pub enum Severity {
 }
 
 macro_rules! rules {
-    ($($(#[$attribute:meta])* $rule:ident),+ $(,)?) => {
+    ($($(#[doc = $documentation:literal])+ $rule:ident => $severity:ident),+ $(,)?) => {
         #[derive(Debug, Copy, Clone, PartialEq, Eq)]
         pub enum Rule {
-            $($(#[$attribute])* $rule,)+
+            $($(#[doc = $documentation])+ $rule,)+
         }
 
         impl Rule {
@@ -75,60 +75,151 @@ macro_rules! rules {
             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,
-}
-
-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,
-        }
-    }
+    // ******** 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 {

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

@@ -33,8 +33,8 @@ pub struct RBSIndexer<'a> {
 
 impl<'a> RBSIndexer<'a> {
     #[must_use]
-    pub fn new(uri: String, source: &'a str) -> Self {
-        let uri_id = UriId::from(&uri);
+    pub fn new(uri: Box<str>, source: &'a str) -> Self {
+        let uri_id = UriId::from(&*uri);
         let local_graph = LocalGraph::new(uri_id, Document::new(uri, source));
 
         Self {
@@ -197,7 +197,7 @@ impl<'a> RBSIndexer<'a> {
             // Skip past indentation to the comment text
             current_offset += line_indent as u32;
 
-            let line_text = line[line_indent..].to_string();
+            let line_text: Box<str> = line[line_indent..].into();
             let line_bytes = line_text.len() as u32;
             let offset = Offset::new(current_offset, current_offset + line_bytes);
             comments.push(Comment::new(offset, line_text));
@@ -1454,7 +1454,7 @@ mod tests {
     fn split_multiline_comments_crlf() {
         // Build the indexer directly to bypass normalize_indentation, which strips \r
         let source = "# First line\r\n# Second line\r\nclass Foo\r\nend\r\n";
-        let mut indexer = RBSIndexer::new("file:///foo.rbs".to_string(), source);
+        let mut indexer = RBSIndexer::new("file:///foo.rbs".into(), source);
         indexer.index();
         let context = LocalGraphTest::from_local_graph("file:///foo.rbs", source, indexer.local_graph());
 

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

@@ -93,8 +93,8 @@ pub struct RubyIndexer<'a> {
 
 impl<'a> RubyIndexer<'a> {
     #[must_use]
-    pub fn new(uri: String, source: &'a str) -> Self {
-        let uri_id = UriId::from(&uri);
+    pub fn new(uri: Box<str>, source: &'a str) -> Self {
+        let uri_id = UriId::from(&*uri);
         let local_graph = LocalGraph::new(uri_id, Document::new(uri, source));
 
         Self {
@@ -120,7 +120,7 @@ impl<'a> RubyIndexer<'a> {
             self.local_graph.add_diagnostic(
                 Rule::ParseError,
                 Offset::from_prism_location(&error.location()),
-                error.message().to_string(),
+                String::from_utf8_lossy(error.message()).to_string(),
             );
         }
 
@@ -128,7 +128,7 @@ impl<'a> RubyIndexer<'a> {
             self.local_graph.add_diagnostic(
                 Rule::ParseWarning,
                 Offset::from_prism_location(&warning.location()),
-                warning.message().to_string(),
+                String::from_utf8_lossy(warning.message()).to_string(),
             );
         }
 
@@ -313,7 +313,9 @@ impl<'a> RubyIndexer<'a> {
                 }
             }
 
-            if let Some(block) = parameters_list.block() {
+            if let Some(block) = parameters_list.block()
+                && let Some(block) = block.as_block_parameter_node()
+            {
                 let location = block.name_loc().unwrap_or_else(|| block.location());
                 let str_id = self.local_graph.intern_string(Self::location_to_string(&location));
 
@@ -1389,8 +1391,8 @@ impl<'a> RubyIndexer<'a> {
         match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
-                let value_loc = symbol.value_loc()?;
-                Some((Self::location_to_string(&value_loc), value_loc))
+                let content_loc = symbol.content_loc();
+                Some((Self::location_to_string(&content_loc), content_loc))
             }
             ruby_prism::Node::StringNode { .. } => {
                 let string = arg.as_string_node().unwrap();
@@ -1522,7 +1524,7 @@ impl CommentGroup {
     // Accepts the next line if it is continuous
     fn accepts(&self, next: &ruby_prism::Comment, source: &str) -> bool {
         let current_end_offset = self.end_offset;
-        let next_line_start_offset = next.location().start_offset();
+        let next_line_start_offset = next.location().start() as usize;
 
         let between = &source.as_bytes()[current_end_offset..next_line_start_offset];
         if !between.iter().all(|&b| b.is_ascii_whitespace()) {
@@ -1538,7 +1540,7 @@ impl CommentGroup {
     // 1. still move the group end offset to the end of the magic comment
     // 2. not add the comment to the comments array
     fn add_comment(&mut self, comment: &ruby_prism::Comment) {
-        self.end_offset = comment.location().end_offset();
+        self.end_offset = comment.location().end() as usize;
         let text = String::from_utf8_lossy(comment.location().as_slice()).to_string();
 
         if text.lines().any(|line| line.starts_with("# @deprecated")) {
@@ -1547,7 +1549,7 @@ impl CommentGroup {
 
         self.comments.push(Comment::new(
             Offset::from_prism_location(&comment.location()),
-            text.trim().to_string(),
+            text.trim().into(),
         ));
     }
 
@@ -1984,12 +1986,18 @@ impl Visit<'_> for RubyIndexer<'_> {
             });
         };
 
-        let message_loc = node.message_loc();
+        let message_loc = if node.name().as_slice().is_empty() {
+            // Incomplete calls like `Foo.` have no message. We still index them using the call operator location, so
+            // that the receiver's singleton class gets created, which completion depends on
+            node.call_operator_loc()
+        } else {
+            node.message_loc()
+        };
 
-        if message_loc.is_none() {
+        let Some(message_loc) = message_loc else {
             // No message, we can't index this node
             return;
-        }
+        };
 
         let message = String::from_utf8_lossy(node.name().as_slice()).to_string();
 
@@ -2217,11 +2225,11 @@ impl Visit<'_> for RubyIndexer<'_> {
                     self.visit(&receiver);
                 }
 
-                self.index_method_reference(message.clone(), &node.message_loc().unwrap(), method_receiver);
+                self.index_method_reference(message.clone(), &message_loc, method_receiver);
 
                 match message.as_str() {
                     ">" | "<" | ">=" | "<=" => {
-                        self.index_method_reference("<=>".to_string(), &node.message_loc().unwrap(), method_receiver);
+                        self.index_method_reference("<=>".to_string(), &message_loc, method_receiver);
                     }
                     _ => {}
                 }
@@ -2382,7 +2390,7 @@ impl Visit<'_> for RubyIndexer<'_> {
             match expression {
                 ruby_prism::Node::SymbolNode { .. } => {
                     let symbol = expression.as_symbol_node().unwrap();
-                    let name = Self::location_to_string(&symbol.value_loc().unwrap());
+                    let name = Self::location_to_string(&symbol.content_loc());
                     self.index_method_reference(name, &node.location(), None);
                 }
                 _ => {
@@ -2394,13 +2402,13 @@ impl Visit<'_> for RubyIndexer<'_> {
 
     fn visit_alias_method_node(&mut self, node: &ruby_prism::AliasMethodNode<'_>) {
         let mut new_name = if let Some(symbol_node) = node.new_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.new_name().location())
         };
 
         let mut old_name = if let Some(symbol_node) = node.old_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.old_name().location())
         };