rigortype 0.1.19 → 0.2.1

data/data/vendored_gem_sigs/rubygems/rubygems_extras.rbs

@@ -0,0 +1,226 @@
+#
+# Rigor-side supplement to the rbs gem's
+# `core/rubygems/*.rbs` declarations.
+#
+# Re-opens the rubygems classes / Gem module to ADD the
+# declarations the upstream RBS omits. Every block below adds
+# new method signatures only — it does NOT redeclare anything
+# the upstream RBS already covers, so the loader does not raise
+# `RBS::DuplicatedDeclarationError`.
+#
+# Driven by the `references/ruby/lib` survey
+# (`docs/CURRENT_WORK.md` § "Queued engine items") which
+# clusters `undefined-method` on Gem-side selectors most-touched
+# by rubygems' own source tree and by bundler. Returns are
+# `untyped` where Rigor cannot infer a precise shape — the goal
+# is to silence false positives, not to author precise sigs.
+#
+module Gem
+  # Singleton additions surfacing in the survey but absent from
+  # the upstream `core/rubygems/rubygems.rbs`. All are real
+  # methods defined in `lib/rubygems/defaults.rb`,
+  # `lib/rubygems.rb`, or the platform-specific override files.
+  def self.target_rbconfig: () -> untyped
+  def self.set_target_rbconfig: (untyped) -> untyped
+  def self.load_safe_marshal: () -> untyped
+  def self.safe_load_marshal: (untyped) -> untyped
+  def self.verbose: () -> bool
+  def self.really_verbose: () -> bool
+  def self.discover_gems_on_require: () -> bool
+  def self.discover_gems_on_require=: (bool) -> bool
+  def self.default_user_install: () -> bool
+  def self.dynamic_library_suffixes: () -> Array[String]
+  def self.extension_api_version: () -> String
+  def self.find_default_spec: (untyped) -> untyped?
+  def self.install_extension_in_lib: () -> bool
+  def self.load_bundler_extensions: () -> untyped
+  def self.load_plugin_files: (?untyped plugins) -> untyped
+  def self.open_file: (String path, String mode) { (IO) -> untyped } -> untyped
+  def self.open_file_with_lock: (String path) { (IO) -> untyped } -> untyped
+  def self.state_file: () -> String
+  def self.vendor_dir: () -> String
+  def self.activate_bin_path: (String name, ?String exec_name, ?untyped requirements) -> String
+end
+
+class Gem::Platform
+  # `Gem::Platform.new(arg)` is the canonical constructor; the
+  # upstream `core/rubygems/platform.rbs` declares the class
+  # but no `initialize`, which forces RBS to default to
+  # `(): void` and the wrong-arity rule fires for every call
+  # site. The accessor / predicate set covers the most-used
+  # surface bundler and rubygems internals touch.
+  def initialize: (*untyped) -> void
+  attr_accessor cpu: String?
+  attr_accessor os: String?
+  attr_accessor version: String?
+  def to_s: () -> String
+  def ==: (untyped) -> bool
+  def ===: (untyped) -> bool
+  def =~: (untyped) -> bool?
+  def eql?: (untyped) -> bool
+  def hash: () -> Integer
+  def match_spec?: (untyped) -> bool
+  def match_gem?: (untyped, untyped) -> bool
+
+  def self.local: () -> Platform
+  def self.match_spec?: (untyped) -> bool
+  def self.match_gem?: (untyped, untyped) -> bool
+  def self.installable?: (untyped) -> bool
+  def self.sort_priority: (untyped) -> Integer
+end
+
+class Gem::Dependency
+  # `Gem::Dependency.new(name, *requirements, type: :runtime)`.
+  # Upstream RBS declares the class shell but no constructor; a
+  # permissive splat keeps the canonical and the
+  # `(name, requirements, type)` invocation forms both silent.
+  def initialize: (*untyped) -> void
+  attr_accessor name: String
+  attr_accessor requirement: Gem::Requirement
+  attr_accessor type: Symbol
+  attr_accessor prerelease: bool
+  def matches_spec?: (untyped) -> bool
+  def match?: (*untyped) -> bool
+  def to_s: () -> String
+  def ==: (untyped) -> bool
+  def eql?: (untyped) -> bool
+  def hash: () -> Integer
+end
+
+class Gem::Specification
+  def self.find_all_by_name: (String name, *untyped requirements) -> Array[Gem::Specification]
+  def self.stubs: () -> Array[untyped]
+  def self.default_stubs: (?String pattern) -> Array[untyped]
+  def self.reset: () -> void
+  def self.from_yaml: (untyped) -> Gem::Specification
+  def self.load: (String path) -> Gem::Specification?
+  def self._all: () -> Array[Gem::Specification]
+  def self.each: () { (Gem::Specification) -> untyped } -> void
+
+  # Instance-side surface widely used by bundler / rubygems
+  # internals. `attr_accessor` mirrors the writer + reader pair
+  # so the survey's `.name=` / `.version=` / `.full_gem_path=` /
+  # `.loaded_from=` / `.post_install_message=` writes resolve too.
+  def activate: () -> untyped
+  def specification_version: () -> Integer
+  def files: () -> Array[String]
+  def default_gem?: () -> bool
+  def spec_file: () -> String
+  def runtime_dependencies: () -> Array[Gem::Dependency]
+  def required_rubygems_version: () -> Gem::Requirement
+  def required_ruby_version: () -> Gem::Requirement
+  def require_paths: () -> Array[String]
+  attr_accessor name: String
+  attr_accessor version: Gem::Version
+  attr_accessor full_gem_path: String
+  attr_accessor loaded_from: String?
+  attr_accessor post_install_message: String?
+end
+
+class Gem::BasicSpecification
+  def version: () -> Gem::Version
+  def executables: () -> Array[String]
+  def name: () -> String
+  def full_name: () -> String
+  def gem_dir: () -> String
+end
+
+class Gem::Version
+  def segments: () -> Array[untyped]
+end
+
+class Gem::Requirement
+  def requirements: () -> Array[untyped]
+  def self.create: (*untyped) -> Gem::Requirement
+end
+
+class Gem::ConfigFile
+  def []: (untyped) -> untyped
+  def []=: (untyped, untyped) -> untyped
+  def write: () -> void
+  def verbose: () -> bool
+  def verbose=: (bool) -> bool
+  def really_verbose: () -> bool
+  def ssl_ca_cert: () -> String?
+  def ssl_client_cert: () -> String?
+  def ssl_verify_mode: () -> Integer?
+  def credentials_path: () -> String
+  def api_keys: () -> Hash[String, String]
+  def cert_expiration_length_days: () -> Integer
+  def sources: () -> Array[String]
+  def update_sources=: (bool) -> bool
+  def unset_api_key!: () -> bool
+  def state_file_writable?: () -> bool
+  def set_api_key: (untyped host, untyped key) -> untyped
+  def rubygems_api_key: () -> String?
+  def rubygems_api_key=: (String?) -> String?
+  def last_update_check: () -> Integer
+  def last_update_check=: (Integer) -> Integer
+  def ipv4_fallback_enabled: () -> bool
+  def install_extension_in_lib: () -> bool
+  def each: () { ([String, untyped]) -> untyped } -> void
+end
+
+class Gem::LoadError < LoadError
+  attr_accessor name: String
+  attr_accessor requirement: Gem::Requirement
+end
+
+class Gem::SourceList
+  include Enumerable[untyped]
+  def initialize: () -> void
+  def include?: (untyped) -> bool
+  def each: () { (untyped) -> untyped } -> void
+  def to_a: () -> Array[untyped]
+  def from: (untyped) -> SourceList
+end
+
+class Gem::RequestSet
+  def initialize: (*untyped) -> void
+  def import: (untyped) -> untyped
+  def source_set: () -> untyped
+  def installed_gems: () -> Hash[String, untyped]
+  def install: (?untyped options) { (?untyped) -> untyped } -> untyped
+  def install_from_gemdeps: (untyped options) { (?untyped) -> untyped } -> untyped
+  def resolve: (?untyped) -> untyped
+  def resolve_current: () -> untyped
+  def resolve_dependencies: () -> untyped
+  def errors: () -> Array[untyped]
+  attr_accessor remote: bool
+  attr_accessor development: bool
+  attr_accessor development_shallow: bool
+  attr_accessor ignore_dependencies: bool
+  attr_accessor prerelease: bool
+  attr_accessor soft_missing: bool
+  attr_accessor without_groups: Array[Symbol]
+  attr_accessor always_install: untyped
+  attr_accessor installing: bool
+end
+
+class Gem::DependencyInstaller
+  def initialize: (*untyped) -> void
+  def install: (untyped, ?untyped) -> Array[untyped]
+  def installed_gems: () -> Array[untyped]
+  def errors: () -> Array[untyped]
+end
+
+class Gem::Uninstaller
+  def initialize: (*untyped) -> void
+  def uninstall: () -> void
+end
+
+class Gem::PathSupport
+  def initialize: (*untyped) -> void
+end
+
+class Gem::Installer
+  def initialize: (*untyped) -> void
+end
+
+class Gem::DependencyInstaller
+  def initialize: (*untyped) -> void
+end
+
+class Gem::MissingSpecError < StandardError
+  def initialize: (*untyped) -> void
+end

data/lib/rigor/analysis/check_rules/ivar_write_collector.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../../source/constant_path"
+
 module Rigor
   module Analysis
     module CheckRules
@@ -80,7 +82,7 @@ module Rigor
 
           case node
           when Prism::ClassNode, Prism::ModuleNode
-            name = qualified_name_for(node.constant_path)
+            name = Source::ConstantPath.qualified_name(node.constant_path)
             if name
               walk(node.body, qualified_prefix + [name]) if node.body
               return
@@ -119,28 +121,6 @@ module Rigor
           @accumulator[class_name][node.name] ||= []
           @accumulator[class_name][node.name] << { node: node, type: rvalue_type }
         end
-
-        # Same shape resolution as `ScopeIndexer.qualified_name_for`
-        # (single-segment ConstantReadNode and dotted
-        # ConstantPathNode). Inlined here to keep the collector
-        # self-contained — the rule lives outside the indexer's
-        # private surface.
-        def qualified_name_for(constant_path_node)
-          case constant_path_node
-          when Prism::ConstantReadNode then constant_path_node.name.to_s
-          when Prism::ConstantPathNode then render_constant_path(constant_path_node)
-          end
-        end
-
-        def render_constant_path(node)
-          prefix =
-            case node.parent
-            when Prism::ConstantReadNode then "#{node.parent.name}::"
-            when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
-            else ""
-            end
-          "#{prefix}#{node.name}"
-        end
       end
     end
   end

data/lib/rigor/analysis/check_rules/rule_walk.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../../source/constant_path"
+
 module Rigor
   module Analysis
     module CheckRules
@@ -183,29 +185,9 @@ module Rigor
           def extend_prefix(node, prefix)
             return prefix unless CLASS_OR_MODULE_NODE_CLASSES.any? { |klass| node.is_a?(klass) }
 
-            name = qualified_name_for(node.constant_path)
+            name = Source::ConstantPath.qualified_name(node.constant_path)
             name ? prefix + [name] : prefix
           end
-
-          # Same shape resolution as `IvarWriteCollector#qualified_name_for`
-          # and `ScopeIndexer.qualified_name_for` (single-segment
-          # ConstantReadNode and dotted ConstantPathNode).
-          def qualified_name_for(constant_path_node)
-            case constant_path_node
-            when Prism::ConstantReadNode then constant_path_node.name.to_s
-            when Prism::ConstantPathNode then render_constant_path(constant_path_node)
-            end
-          end
-
-          def render_constant_path(node)
-            prefix =
-              case node.parent
-              when Prism::ConstantReadNode then "#{node.parent.name}::"
-              when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
-              else ""
-              end
-            "#{prefix}#{node.name}"
-          end
         end
       end
     end

data/lib/rigor/analysis/check_rules/self_closedness_scanner.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../../source/constant_path"
+
 module Rigor
   module Analysis
     module CheckRules
@@ -45,20 +47,27 @@ module Rigor
 
           case node
           when Prism::ModuleNode
-            name = constant_path_name(node.constant_path)
+            name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
             child_prefix = name ? prefix + [name] : prefix
             names << child_prefix.join("::") if name
             walk(node.body, child_prefix, names) if node.body
           when Prism::ClassNode
-            name = constant_path_name(node.constant_path)
+            name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
             child_prefix = name ? prefix + [name] : prefix
-            names << child_prefix.join("::") if name && dynamic_attr_class?(node)
+            names << child_prefix.join("::") if name && class_surface_open?(node)
             walk(node.body, child_prefix, names) if node.body
           else
             node.compact_child_nodes.each { |child| walk(child, prefix, names) }
           end
         end
 
+        # A class whose source-declared surface cannot be fully enumerated:
+        # a dynamic `attr_*` accessor, or a non-constant (dynamically produced)
+        # superclass.
+        def class_surface_open?(class_node)
+          dynamic_attr_class?(class_node) || dynamic_superclass?(class_node)
+        end
+
         # True when the class body directly invokes an `attr_*` macro with a
         # non-literal argument (a splat, a constant, a method call) — the
         # synthesized accessor names are then not statically knowable.
@@ -81,18 +90,18 @@ module Rigor
           args.any? { |arg| !arg.is_a?(Prism::SymbolNode) && !arg.is_a?(Prism::StringNode) }
         end
 
-        # Renders a class/module path node to its source-qualified name
-        # (`Foo`, `Foo::Bar`, leading `::` stripped); nil for a dynamic
-        # constant path the scanner cannot name statically.
-        def constant_path_name(node)
-          case node
-          when Prism::ConstantReadNode
-            node.name.to_s
-          when Prism::ConstantPathNode
-            parent = node.parent ? constant_path_name(node.parent) : nil
-            child = node.name.to_s
-            node.parent.nil? ? child : (parent && "#{parent}::#{child}")
-          end
+        # True when the class declares a superclass that is not a static
+        # constant — `class X < DelegateClass(Array)` / `< Struct.new(...)` /
+        # `< Data.define(...)`. The inherited surface is then a dynamically
+        # produced class the engine cannot enumerate from a constant name (the
+        # superclass is a method call, so `discovered_superclasses` never
+        # records it and the closed-class gate would wrongly treat the class as
+        # standalone), so a missed self-call is not provably a typo.
+        def dynamic_superclass?(class_node)
+          superclass = class_node.superclass
+          return false if superclass.nil?
+
+          !superclass.is_a?(Prism::ConstantReadNode) && !superclass.is_a?(Prism::ConstantPathNode)
         end
       end
     end