rubydex 0.4.0-aarch64-linux → 0.4.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0ae408bab2d715dbc24c9788310c8387d479578b43f3ed91a5613694da7c7f3
-  data.tar.gz: f91df4834446b385e52a407f3a45dea75c3cbb1e01f843a7a0176a3441a9c952
+  metadata.gz: a70d28b6e2a005cc04ca033934b7bc32c17d88b76baa0c02b914a1be690fe321
+  data.tar.gz: 7cf3e4cab8ee5d14236749f9fdb3a215e5bc92a276f32945fa869a179e8e58bf
 SHA512:
-  metadata.gz: 59f82f4466af541704a9a8967b022234130ae4c12be48f1a7b7f50b8a1d58bf63c0c42ae3e90d8ed6f6068bd69fab3f5e8a08ecb388398b530a500effb9e4b85
-  data.tar.gz: 896414c62dcac91658b49031afe905b74f3ef1d68d07205ff292805f2b05cf50dee1155305d45e83c82a172a8ea24f550cb7e590aa5a649c56abaa6890992f75
+  metadata.gz: f906b9f461dc0bffe39965ad48959b22e4ca78096856aaa9058ce4ac89d0351095769fb68fc5ef6b5ee1f3577b594902ea8cfa258c991dc6ffb1abd7ea7e31c3
+  data.tar.gz: f29ce56721abd682206660c4a605b9236a67f61016242d85ebd2f9b2d4137c34538cb6a278d8e48dfe49171e9024b6cb938114f9d5e61d1465595386f0d76d35

data/README.md

@@ -114,7 +114,7 @@ Thread safety comes from an `RwLock` on the Rust side, **not** from Ruby's
 
 All built-in tools are experimental. These tools can change without deprecation warnings.
 
-### `rdx query`
+### Querying
 
 Rubydex exposes the indexed graph through a read-only subset of the
 [Cypher](https://opencypher.org/) query language. Only read clauses (`MATCH`,
@@ -153,27 +153,11 @@ puts result.render("json")
 puts Rubydex::Query.schema("table")
 ```
 
-### `rdx lint`
+### Linter
 
-Put rule files under `rubydex_linter/rules`. Each rule must inherit from `Rubydex::Linter::CustomRule`.
+See the [linter docs](docs/linter.md).
 
-Run the linter:
-
-```bash
-bundle exec rdx lint
-```
-
-Rubydex uses the bundle root, or the current directory when no bundle is available.
-
-Configure a rule in `rubydex.toml`:
-
-```toml
-[linter.rules.<Rule name>]
-enabled = true
-exclude = ["path_to_skip/**"]
-```
-
-### `rdx mcp`
+### MCP server
 
 Rubydex can run as an MCP (Model Context Protocol) server, enabling AI assistants
 like Claude to semantically query your Ruby codebase.

data/ext/rubydex/definition.c

@@ -38,6 +38,17 @@ VALUE cClassVariableDefinition;
 VALUE cMethodAliasDefinition;
 VALUE cGlobalVariableAliasDefinition;
 
+uint64_t rdxi_definition_id_for_graph(VALUE definition, VALUE graph_obj) {
+    HandleData *data;
+    TypedData_Get_Struct(definition, HandleData, &handle_type, data);
+
+    if (data->graph_obj != graph_obj) {
+        rb_raise(rb_eArgError, "definition must belong to this graph");
+    }
+
+    return data->id;
+}
+
 // Keep this in sync with definition.rs
 VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
     switch (kind) {
@@ -153,6 +164,25 @@ static VALUE rdxr_definition_name(VALUE self) {
     return rdxi_owned_c_string_to_ruby(name);
 }
 
+/*
+ * call-seq:
+ *   raw_name -> String
+ *
+ * Returns the class, module, or constant name as written in source, preserving explicit parent scopes like "Foo::Bar"
+ * and rooted paths like "::Bar".
+ */
+static VALUE rdxr_definition_raw_name(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const char *name = rdx_definition_raw_name(graph, data->id);
+    if (name == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition not found");
+    }
+
+    return rdxi_owned_c_string_to_ruby(name);
+}
+
 /*
  * call-seq:
  *   deprecated? -> bool
@@ -442,6 +472,7 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "document", rdxr_definition_document, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
+    rb_define_method(cClassDefinition, "raw_name", rdxr_definition_raw_name, 0);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
     rb_define_method(cClassDefinition, "mixins", rdxr_definition_mixins, 0);
 
@@ -449,10 +480,13 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cSingletonClassDefinition, "mixins", rdxr_definition_mixins, 0);
 
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    rb_define_method(cModuleDefinition, "raw_name", rdxr_definition_raw_name, 0);
     rb_define_method(cModuleDefinition, "mixins", rdxr_definition_mixins, 0);
 
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
+    rb_define_method(cConstantDefinition, "raw_name", rdxr_definition_raw_name, 0);
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
+    rb_define_method(cConstantAliasDefinition, "raw_name", rdxr_definition_raw_name, 0);
     cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
     cMethodVisibilityDefinition = rb_define_class_under(mRubydex, "MethodVisibilityDefinition", cDefinition);
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);

data/ext/rubydex/definition.h

@@ -22,6 +22,9 @@ extern VALUE cGlobalVariableAliasDefinition;
 
 void rdxi_initialize_definition(VALUE mRubydex);
 
+// Returns the definition ID after verifying that the definition belongs to `graph_obj`.
+uint64_t rdxi_definition_id_for_graph(VALUE definition, VALUE graph_obj);
+
 // Returns the Ruby class for a given DefinitionKind without calling back into Rust
 VALUE rdxi_definition_class_for_kind(DefinitionKind kind);
 

data/ext/rubydex/diagnostic.c

@@ -6,11 +6,8 @@
  * mRubydex = rb_define_module("Rubydex")
  */
 
-static VALUE mRubydex;
 static VALUE mRules;
 VALUE cDiagnostic;
-static VALUE cRule;
-static ID id_default_severity;
 
 VALUE rdxi_build_diagnostic_severity_value(VALUE mRubydex, DiagnosticSeverity severity) {
     VALUE mSeverity = rb_const_get(mRubydex, rb_intern("Severity"));
@@ -31,55 +28,11 @@ VALUE rdxi_build_diagnostic_severity_value(VALUE mRubydex, DiagnosticSeverity se
     return Qnil;
 }
 
-/*
- * call-seq:
- *   default_severity -> Rubydex::Severity::Base
- *
- * Returns the Rubydex::Severity subclass the diagnostics of this rule get unless the configuration overrides it.
- */
-static VALUE rdxr_generated_rule_default_severity(VALUE self) {
-    VALUE severity = rb_attr_get(self, id_default_severity);
-
-    // Class-level instance variables are not inherited, so a class inheriting from a generated rule reaches this without
-    // a severity of its own.
-    if (NIL_P(severity)) {
-        rb_raise(rb_eRuntimeError, "Rule %s has no default severity", rb_class2name(self));
-    }
-
-    return severity;
-}
-
-// Generates a rule class for every rule the graph can report. Severities are resolved here rather than when they are
-// read, which is why Rubydex::Severity is loaded before this extension (see `lib/rubydex.rb`).
-static void define_generated_rules(void) {
-    CRuleArray rule_array = rdx_rules();
-    VALUE rules = rb_ary_new_capa((long)rule_array.len);
-
-    for (size_t i = 0; i < rule_array.len; i++) {
-        CRule built_in_rule = rule_array.items[i];
-        VALUE name = rb_utf8_str_new(built_in_rule.name, (long)built_in_rule.name_length);
-        VALUE rule = rb_define_class_under(mRules, StringValueCStr(name), cRule);
-        VALUE severity = rdxi_build_diagnostic_severity_value(mRubydex, built_in_rule.default_severity);
-
-        rb_ivar_set(rule, id_default_severity, severity);
-        rb_define_singleton_method(rule, "default_severity", rdxr_generated_rule_default_severity, 0);
-        rb_ary_push(rules, rule);
-    }
-
-    rdx_rules_free(rule_array);
-    rb_define_const(mRules, "ALL", rb_obj_freeze(rules));
-}
-
 VALUE rdxi_rule_class_from_name(const char *name, size_t length) {
     return rb_const_get_at(mRules, rb_intern2(name, (long)length));
 }
 
 void rdxi_initialize_diagnostic(VALUE moduleRubydex) {
-    mRubydex = moduleRubydex;
-    id_default_severity = rb_intern("@default_severity");
-
-    cDiagnostic = rb_define_class_under(mRubydex, "Diagnostic", rb_cObject);
-    cRule = rb_define_class_under(mRubydex, "Rule", rb_cObject);
-    mRules = rb_define_module_under(mRubydex, "Rules");
-    define_generated_rules();
+    cDiagnostic = rb_define_class_under(moduleRubydex, "Diagnostic", rb_cObject);
+    mRules = rb_define_module_under(moduleRubydex, "Rules");
 }

data/ext/rubydex/extconf.rb

@@ -23,12 +23,12 @@ release = ENV["RELEASE"] || !developing_rubydex
 root_dir = gem_dir.join("rust")
 target_dir = root_dir.join("target")
 target_dir = target_dir.join("x86_64-pc-windows-gnu") if Gem.win_platform?
-target_dir = target_dir.join(release ? "release" : "debug")
+target_dir = target_dir.join("$(RUST_PROFILE)")
 
 bindings_path = root_dir.join("rubydex-sys").join("rustbindings.h")
 
 cargo_args = ["--manifest-path #{root_dir.join("Cargo.toml")}"]
-cargo_args << "--release" if release
+cargo_args << "$(CARGO_PROFILE_FLAG)"
 
 if Gem.win_platform?
   cargo_args << "--target x86_64-pc-windows-gnu"
@@ -102,6 +102,8 @@ makefile = File.read("Makefile")
 
 new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.chomp)
   .PHONY: compile_rust
+  RUST_PROFILE = $(if $(strip $(RELEASE)),release,#{developing_rubydex ? "debug" : "release"})
+  CARGO_PROFILE_FLAG = $(if $(filter release,$(RUST_PROFILE)),--release)
   RUST_SRCS = #{File.expand_path("Cargo.toml", root_dir)} #{File.expand_path("Cargo.lock", root_dir)} #{rust_srcs.join(" ")}
 
   .rust_built: $(RUST_SRCS)

data/ext/rubydex/graph.c

@@ -1,6 +1,7 @@
 #include "graph.h"
 #include "config.h"
 #include "declaration.h"
+#include "definition.h"
 #include "diagnostic.h"
 #include "document.h"
 #include "location.h"
@@ -256,6 +257,30 @@ static VALUE rdxr_graph_fuzzy_search(int argc, VALUE *argv, VALUE self) {
     return rdxr_graph_yield_search_results(self, iter);
 }
 
+/*
+ * call-seq:
+ *   dead_code_candidates -> Enumerator[Rubydex::Declaration]
+ *
+ * Returns an enumerator over declarations that may be unused because the analysis could not find any references to
+ * them. This misses metaprogramming or untyped code, which is why the term candidates is used.
+ *
+ * Currently, only supports constants.
+ */
+static VALUE rdxr_graph_dead_code_candidates(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("dead_code_candidates"), 0, NULL);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_dead_code_candidates(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
+
+    return self;
+}
+
 // Body function for rb_ensure in Graph#documents
 static VALUE graph_documents_yield(VALUE args) {
     VALUE self = rb_ary_entry(args, 0);
@@ -486,26 +511,48 @@ static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
 
 /*
  * call-seq:
- *   resolve_constant(name, nesting) -> Rubydex::Declaration?
+ *   resolve_constant(name, context) -> Rubydex::Declaration?
  *
- * Runs the resolver on a single constant reference to determine what it points to.
+ * Runs the resolver on a single constant reference using an array of nesting names or a namespace definition as its
+ * context.
  */
-static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nesting) {
+static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE context) {
     Check_Type(const_name, T_STRING);
-    rdxi_check_array_of_strings(nesting);
     const char *const_name_string = StringValueCStr(const_name);
 
-    // Convert the given file paths into a char** array, so that we can pass to Rust
-    size_t length = RARRAY_LEN(nesting);
-    char **converted_file_paths = rdxi_str_array_to_char(nesting, length);
-
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    const CDeclaration *decl =
-        rdx_graph_resolve_constant(graph, const_name_string, (const char **)converted_file_paths, length);
+    const CDeclaration *decl;
+    if (RB_TYPE_P(context, T_ARRAY)) {
+        rdxi_check_array_of_strings(context);
+
+        size_t length = RARRAY_LEN(context);
+        char **converted_names = rdxi_str_array_to_char(context, length);
+        decl = rdx_graph_resolve_constant(graph, const_name_string, (const char **)converted_names, length);
+        rdxi_free_str_array(converted_names, length);
+    } else if (rb_obj_is_kind_of(context, cClassDefinition) ||
+               rb_obj_is_kind_of(context, cSingletonClassDefinition) ||
+               rb_obj_is_kind_of(context, cModuleDefinition)) {
+        uint64_t definition_id = rdxi_definition_id_for_graph(context, self);
+        CDefinitionConstantResolutionResult result =
+            rdx_graph_resolve_constant_from_definition(graph, const_name_string, definition_id);
+
+        if (result.status == CDefinitionConstantResolution_DefinitionNotFound) {
+            rb_raise(rb_eRuntimeError, "Definition not found");
+        }
+        if (result.status == CDefinitionConstantResolution_InvalidDefinitionKind) {
+            // This is unreachable because the rb_obj_is_kind_of checks above only accept supported definition kinds.
+            rb_raise(rb_eRuntimeError, "Unexpected definition kind");
+        }
 
-    rdxi_free_str_array(converted_file_paths, length);
+        decl = result.declaration;
+    } else {
+        rb_raise(
+            rb_eTypeError,
+            "context must be an Array of Strings, ClassDefinition, SingletonClassDefinition, or ModuleDefinition"
+        );
+    }
 
     if (decl == NULL) {
         return Qnil;
@@ -938,6 +985,7 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
     rb_define_method(cGraph, "search", rdxr_graph_search, -1);
     rb_define_method(cGraph, "fuzzy_search", rdxr_graph_fuzzy_search, -1);
+    rb_define_method(cGraph, "dead_code_candidates", rdxr_graph_dead_code_candidates, 0);
     rb_define_method(cGraph, "encoding=", rdxr_graph_set_encoding, 1);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);

data/lib/rubydex/cli/command/lint/explain.rb

@@ -9,8 +9,10 @@ module Rubydex
       class Lint
         # `rdx lint explain <RULE>` — prints documentation for rules with a matching name.
         class Explain < Command
-          BASE_RULE_NAME = "Rubydex::Linter::CustomRule" #: String
-          BASE_RULE_PATH = File.expand_path("../../../linter/custom_rule.rb", __dir__) #: String
+          BASE_PATHS = [
+            File.expand_path("../../../linter/custom_rule.rb", __dir__),
+            File.expand_path("../../../rule.rb", __dir__),
+          ] #: Array[String]
 
           class << self
             #: -> String
@@ -30,17 +32,17 @@ module Rubydex
             workspace_path = current_workspace_path
 
             graph = Rubydex::Graph.configure_for_workspace(workspace_path)
-            graph.index_all([BASE_RULE_PATH, *Rubydex::Linter::RuleLoader.paths(workspace_path)])
+            graph.index_all([*BASE_PATHS, *Rubydex::Linter::RuleLoader.paths(workspace_path)])
             graph.resolve
 
-            base_rule = graph[BASE_RULE_NAME]
-            abort("Base rule class #{BASE_RULE_NAME} is not found. This is likely an issue in Rubydex itself") unless base_rule.is_a?(Rubydex::Class)
+            base_rule = graph["Rubydex::Rule"]
+            abort("Base rule class is not found. This is an issue in Rubydex itself") unless base_rule.is_a?(Rubydex::Class)
 
             rule_declarations = base_rule.descendants.grep(Rubydex::Class) #: as Array[Rubydex::Class]
             matched_rule_names = rule_declarations.filter_map do |declaration|
               declaration_name = declaration.name
               next unless declaration_name
-              next if declaration_name == BASE_RULE_NAME
+              next if declaration_name == "Rubydex::Rule" || declaration_name == "Rubydex::Linter::CustomRule"
               next unless declaration_name.end_with?(rule_name)
 
               declaration

data/lib/rubydex/cli/command/lint.rb

@@ -35,7 +35,7 @@ module Rubydex
           require "rubydex/linter"
 
           custom_rules = load_linter_rules(workspace_path)
-          warn_unknown_rules(custom_rules)
+          warn_unknown_rules
 
           graph = build_graph($stderr, workspace_path:, config:)
           runner = Rubydex::Linter::Runner.new(graph, custom_rules:, config: linter_config)
@@ -64,9 +64,15 @@ module Rubydex
           @linter_config ||= config.linter #: Rubydex::LinterConfig?
         end
 
-        #: (Array[singleton(Rubydex::Linter::CustomRule)] custom_rule_classes) -> void
-        def warn_unknown_rules(custom_rule_classes)
-          known_rule_names = (Rubydex::Rules::ALL + custom_rule_classes).map(&:rule_name).uniq.sort
+        #: () -> void
+        def warn_unknown_rules
+          known_rule_names = (Rule.subclasses + Rubydex::Linter::CustomRule.subclasses).filter_map do |rule|
+            name = rule.rule_name
+            name unless name == "CustomRule"
+          end
+          known_rule_names.uniq!
+          known_rule_names.sort!
+
           unknown_rule_names = linter_config.rules.keys.reject { |name| known_rule_names.include?(name) }.sort
           return if unknown_rule_names.empty?
 

data/lib/rubydex/linter/rule_loader.rb

@@ -4,7 +4,7 @@ module Rubydex
   module Linter
     # Loads project and bundled-gem rules using the Rubydex linter path convention.
     class RuleLoader
-      BUILT_IN_RULE_GLOB = File.expand_path("../../rubydex_linter/rules/**/*.rb", __dir__) #: String
+      BUILT_IN_RULE_GLOB = File.expand_path("../../{rubydex_linter,rubydex}/rules/**/*.rb", __dir__) #: String
       RULE_GLOB = "rubydex_linter/rules/**/*.rb" #: String
 
       class << self

data/lib/rubydex/rules/dynamic_ancestor.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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
+    # ```
+    class DynamicAncestor < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/dynamic_constant_reference.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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.
+    # ```
+    class DynamicConstantReference < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/dynamic_singleton_definition.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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
+    # ```
+    class DynamicSingletonDefinition < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/invalid_constant_visibility.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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.
+    # ```
+    class InvalidConstantVisibility < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/invalid_method_visibility.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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.
+    # ```
+    class InvalidMethodVisibility < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/parse_error.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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
+    # ```
+    class ParseError < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Error
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/parse_warning.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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
+    # ```
+    class ParseWarning < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/top_level_mixin_self.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # 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
+    # ```
+    class TopLevelMixinSelf < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end