rubydex 0.4.0-aarch64-linux → 0.4.2-aarch64-linux

data/rbi/rubydex.rbi

@@ -175,8 +175,17 @@ class Rubydex::AttrAccessorDefinition < Rubydex::Definition; end
 class Rubydex::AttrReaderDefinition < Rubydex::Definition; end
 class Rubydex::AttrWriterDefinition < Rubydex::Definition; end
 class Rubydex::ClassVariableDefinition < Rubydex::Definition; end
-class Rubydex::ConstantAliasDefinition < Rubydex::Definition; end
-class Rubydex::ConstantDefinition < Rubydex::Definition; end
+
+class Rubydex::ConstantAliasDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
+class Rubydex::ConstantDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
 class Rubydex::GlobalVariableAliasDefinition < Rubydex::Definition; end
 class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
@@ -271,6 +280,9 @@ class Rubydex::Signature::BlockParameter < Rubydex::Signature::Parameter; end
 class Rubydex::ModuleDefinition < Rubydex::Definition
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::SingletonClassDefinition < Rubydex::Definition
@@ -284,6 +296,9 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::Mixin
@@ -337,80 +352,6 @@ class Rubydex::Rule
   end
 end
 
-module Rubydex::Rules
-  ALL = T.let(T.unsafe(nil), T::Array[T.class_of(Rubydex::Rule)])
-end
-
-class Rubydex::Rules::ParseError < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::ParseWarning < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicConstantReference < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicSingletonDefinition < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicAncestor < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::TopLevelMixinSelf < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::InvalidConstantVisibility < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::InvalidMethodVisibility < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::UndefinedMethodVisibilityTarget < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::UndefinedConstantVisibilityTarget < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
 class Rubydex::RelatedInformation
   sig { params(message: String, location: Rubydex::Location).void }
   def initialize(message, location); end
@@ -594,58 +535,6 @@ class Rubydex::Linter::Rules::RuleStructure < Rubydex::Linter::CustomRule
   def lint; end
 end
 
-class Rubydex::Linter::RuleTestCase < Minitest::Test
-  DEFAULT_FILE = T.let(T.unsafe(nil), String)
-  ANNOTATION_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-  sig { returns(String) }
-  def workspace_path; end
-
-  sig { params(name: String).void }
-  def initialize(name); end
-
-  sig { void }
-  def teardown; end
-
-  sig { returns(T.class_of(Rubydex::Linter::CustomRule)) }
-  def rule_class; end
-
-  sig { params(sources: T::Hash[String, String]).void }
-  def add_shared_source(sources); end
-
-  sig { returns(T::Array[String]) }
-  def ignored_diagnostic_files; end
-
-  sig { returns(Rubydex::LinterConfig) }
-  def rule_config; end
-
-  sig do
-    params(
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).returns(T::Array[Rubydex::Diagnostic])
-  end
-  def assert_diagnostics(*args, &rule_builder); end
-
-  sig do
-    params(
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).returns(T::Array[Rubydex::Diagnostic])
-  end
-  def assert_no_diagnostics(*args, &rule_builder); end
-
-  sig do
-    params(
-      dependency: String,
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      after_excluding: T::Array[String],
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).void
-  end
-  def assert_handles_missing_required_dependency(dependency, *args, after_excluding: [], &rule_builder); end
-end
-
 class Rubydex::Linter::Runner
   sig do
     params(
@@ -891,8 +780,18 @@ class Rubydex::Graph
   sig { returns(T.self_type) }
   def resolve; end
 
-  sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(Rubydex::Declaration)) }
-  def resolve_constant(name, nesting); end
+  sig do
+    params(
+      name: String,
+      context: T.any(
+        T::Array[String],
+        Rubydex::ClassDefinition,
+        Rubydex::SingletonClassDefinition,
+        Rubydex::ModuleDefinition,
+      ),
+    ).returns(T.nilable(Rubydex::Declaration))
+  end
+  def resolve_constant(name, context); end
 
   sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Rubydex::Document)) }
   def resolve_require_path(require_path, load_paths); end
@@ -903,6 +802,9 @@ class Rubydex::Graph
   sig { params(queries: String).returns(T::Enumerable[Rubydex::Declaration]) }
   def fuzzy_search(*queries); end
 
+  sig { returns(T::Enumerable[Rubydex::Declaration]) }
+  def dead_code_candidates; end
+
   sig { params(encoding: String).void }
   def encoding=(encoding); end
 

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 {