rigortype 0.0.1 → 0.0.3

data/lib/rigor/analysis/check_rules.rb

@@ -41,6 +41,30 @@ module Rigor
     # the first preview; later slices broaden it.
     # rubocop:disable Metrics/ModuleLength
     module CheckRules
+      # Stable identifiers for each rule. Used by the
+      # configuration `disable:` list and the in-source
+      # `# rigor:disable <rule>` suppression comment system
+      # to identify diagnostics by category. Rule identifiers
+      # are kebab-case strings; new rules MUST register here
+      # so user configuration can refer to them.
+      RULE_UNDEFINED_METHOD = "undefined-method"
+      RULE_WRONG_ARITY = "wrong-arity"
+      RULE_ARGUMENT_TYPE = "argument-type-mismatch"
+      RULE_NIL_RECEIVER = "possible-nil-receiver"
+      RULE_DUMP_TYPE = "dump-type"
+      RULE_ASSERT_TYPE = "assert-type"
+      RULE_ALWAYS_RAISES = "always-raises"
+
+      ALL_RULES = [
+        RULE_UNDEFINED_METHOD,
+        RULE_WRONG_ARITY,
+        RULE_ARGUMENT_TYPE,
+        RULE_NIL_RECEIVER,
+        RULE_DUMP_TYPE,
+        RULE_ASSERT_TYPE,
+        RULE_ALWAYS_RAISES
+      ].freeze
+
       module_function
 
       # Yields diagnostics for every unrecognised method call on
@@ -53,7 +77,7 @@ module Rigor
       # @param root [Prism::Node]
       # @param scope_index [Hash{Prism::Node => Rigor::Scope}]
       # @return [Array<Rigor::Analysis::Diagnostic>]
-      def diagnose(path:, root:, scope_index:) # rubocop:disable Metrics/CyclomaticComplexity
+      def diagnose(path:, root:, scope_index:, comments: [], disabled_rules: []) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         diagnostics = []
         Source::NodeWalker.each(root) do |node|
           next unless node.is_a?(Prism::CallNode)
@@ -64,6 +88,9 @@ module Rigor
           arity_diagnostic = wrong_arity_diagnostic(path, node, scope_index)
           diagnostics << arity_diagnostic if arity_diagnostic
 
+          arg_type_diagnostic = argument_type_diagnostic(path, node, scope_index)
+          diagnostics << arg_type_diagnostic if arg_type_diagnostic
+
           nil_diagnostic = nil_receiver_diagnostic(path, node, scope_index)
           diagnostics << nil_diagnostic if nil_diagnostic
 
@@ -72,8 +99,57 @@ module Rigor
 
           assert_diagnostic = assert_type_diagnostic(path, node, scope_index)
           diagnostics << assert_diagnostic if assert_diagnostic
+
+          raises_diagnostic = always_raises_diagnostic(path, node, scope_index)
+          diagnostics << raises_diagnostic if raises_diagnostic
+        end
+        filter_suppressed(diagnostics, comments: comments, disabled_rules: disabled_rules)
+      end
+
+      # v0.0.2 #6 — diagnostic suppression. Two kinds of
+      # suppression compose:
+      #
+      # - **Project-level**: `disabled_rules` is the
+      #   project's `.rigor.yml` `disable:` list. Any
+      #   diagnostic whose `rule` is in the list is dropped.
+      # - **In-source**: `# rigor:disable <rule1>, <rule2>`
+      #   on the same line as the offending expression
+      #   suppresses the matching diagnostic for that line
+      #   only. `# rigor:disable all` on a line suppresses
+      #   every rule on that line.
+      #
+      # Diagnostics with `rule == nil` (parse errors, path
+      # errors, internal analyzer errors) are NEVER
+      # suppressed — they represent failures the user cannot
+      # silence away.
+      def filter_suppressed(diagnostics, comments:, disabled_rules:)
+        suppressions = parse_suppression_comments(comments)
+        disabled = disabled_rules.to_set(&:to_s)
+
+        diagnostics.reject do |diagnostic|
+          rule = diagnostic.rule
+          next false if rule.nil?
+          next true if disabled.include?(rule)
+
+          line_rules = suppressions[diagnostic.line]
+          line_rules && (line_rules.include?("all") || line_rules.include?(rule))
         end
-        diagnostics
+      end
+
+      SUPPRESSION_PATTERN = /#\s*rigor:disable\s+(?<rules>[\w,\s-]+)/
+      private_constant :SUPPRESSION_PATTERN
+
+      def parse_suppression_comments(comments)
+        result = Hash.new { |h, k| h[k] = Set.new }
+        comments.each do |comment|
+          source = comment.location.slice
+          match = SUPPRESSION_PATTERN.match(source)
+          next if match.nil?
+
+          rules = match[:rules].to_s.split(/[\s,]+/).reject(&:empty?)
+          rules.each { |rule| result[comment.location.start_line] << rule }
+        end
+        result
       end
 
       # rubocop:disable Metrics/ClassLength
@@ -262,6 +338,13 @@ module Rigor
         end
 
         def arity_eligible?(function)
+          # `RBS::Types::UntypedFunction` (used for `(?) ->`
+          # untyped sigs) does not expose the per-arity
+          # accessors. Treating it as ineligible is the
+          # correct conservative move: an untyped function
+          # has no static arity to enforce.
+          return false unless function.respond_to?(:required_keywords)
+
           function.required_keywords.empty? && function.trailing_positionals.empty?
         end
 
@@ -361,13 +444,14 @@ module Rigor
         # The diagnostic does NOT count toward `Result#error_count`
         # so a fixture peppered with `dump_type` calls still
         # passes `rigor check`.
-        def dump_type_diagnostic(path, call_node, scope_index)
+        def dump_type_diagnostic(path, call_node, scope_index) # rubocop:disable Metrics/CyclomaticComplexity
           return nil unless rigor_testing_call?(call_node, :dump_type)
           return nil if call_node.arguments.nil? || call_node.arguments.arguments.empty?
 
           arg = call_node.arguments.arguments.first
           scope = scope_index[arg] || scope_index[call_node]
           return nil if scope.nil?
+          return nil if inside_rigor_testing?(scope)
 
           type = scope.type_of(arg)
           location = call_node.message_loc || call_node.location
@@ -376,7 +460,8 @@ module Rigor
             line: location.start_line,
             column: location.start_column + 1,
             message: "dump_type: #{type.describe(:short)}",
-            severity: :info
+            severity: :info,
+            rule: RULE_DUMP_TYPE
           )
         end
 
@@ -388,7 +473,7 @@ module Rigor
         # is emitted; matching calls produce no output. This
         # lets a fixture document its expected types inline:
         # subsequent `rigor check` runs flag any drift.
-        def assert_type_diagnostic(path, call_node, scope_index) # rubocop:disable Metrics/CyclomaticComplexity
+        def assert_type_diagnostic(path, call_node, scope_index) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           return nil unless rigor_testing_call?(call_node, :assert_type)
           return nil if call_node.arguments.nil? || call_node.arguments.arguments.size < 2
 
@@ -398,6 +483,7 @@ module Rigor
           value_node = call_node.arguments.arguments[1]
           scope = scope_index[value_node] || scope_index[call_node]
           return nil if scope.nil?
+          return nil if inside_rigor_testing?(scope)
 
           actual = scope.type_of(value_node).describe(:short)
           expected = expected_node.unescaped.to_s
@@ -419,6 +505,24 @@ module Rigor
         RIGOR_TESTING_RECEIVERS = ["Rigor", "Rigor::Testing", "Testing"].freeze
         private_constant :RIGOR_TESTING_RECEIVERS
 
+        # The dump/assert helpers' own implementation methods
+        # call back into `Testing.dump_type` / `assert_type` to
+        # share the no-op runtime stub. We do NOT want those
+        # internal calls to surface diagnostics — they are
+        # reflexive plumbing, not user assertions. This filter
+        # skips diagnostics when the call site's `self_type` is
+        # the `Rigor` or `Rigor::Testing` module itself.
+        SELF_REFERENTIAL_SCOPES = ["Rigor", "Rigor::Testing"].freeze
+        private_constant :SELF_REFERENTIAL_SCOPES
+
+        def inside_rigor_testing?(scope)
+          self_type = scope.self_type
+          return false if self_type.nil?
+          return false unless self_type.respond_to?(:class_name)
+
+          SELF_REFERENTIAL_SCOPES.include?(self_type.class_name)
+        end
+
         def rigor_testing_call?(call_node, method_name)
           return false unless call_node.name == method_name
 
@@ -449,6 +553,7 @@ module Rigor
         def build_assert_type_diagnostic(path, call_node, expected, actual)
           location = call_node.message_loc || call_node.location
           Diagnostic.new(
+            rule: RULE_ASSERT_TYPE,
             path: path,
             line: location.start_line,
             column: location.start_column + 1,
@@ -460,6 +565,7 @@ module Rigor
         def build_nil_receiver_diagnostic(path, call_node)
           location = call_node.message_loc || call_node.location
           Diagnostic.new(
+            rule: RULE_NIL_RECEIVER,
             path: path,
             line: location.start_line,
             column: location.start_column + 1,
@@ -468,6 +574,190 @@ module Rigor
           )
         end
 
+        # Diagnoses calls that the analyzer can prove will always
+        # raise. Today the only triggering shape is integer
+        # division/modulo by a literal zero divisor:
+        #
+        #   5 / 0          # => ZeroDivisionError
+        #   x.modulo(0)    # => ZeroDivisionError when x: Integer
+        #   xs.size % 0    # same — non_negative_int / Constant[0]
+        #
+        # Float divmod by zero returns Infinity/NaN at runtime, so
+        # the rule restricts to Integer-rooted receivers (`Constant`,
+        # `IntegerRange`, `Nominal[Integer]`). The argument MUST be a
+        # `Constant<Integer>` whose value is exactly zero — a
+        # `Union[Constant[0], Constant[2]]` divisor "may" raise,
+        # which we surface separately (future slice).
+        INTEGER_RAISING_OPERATORS = %i[/ % div modulo divmod].freeze
+        private_constant :INTEGER_RAISING_OPERATORS
+
+        def always_raises_diagnostic(path, call_node, scope_index)
+          return nil unless integer_zero_division?(call_node, scope_index)
+
+          build_always_raises_diagnostic(path, call_node)
+        end
+
+        def integer_zero_division?(call_node, scope_index)
+          return false unless raising_call_shape?(call_node)
+
+          scope = scope_index[call_node]
+          return false if scope.nil?
+          return false unless integer_rooted_for_diagnostic?(scope.type_of(call_node.receiver))
+
+          arg = single_argument(call_node)
+          arg && integer_zero_constant?(scope.type_of(arg))
+        end
+
+        def raising_call_shape?(call_node)
+          !call_node.receiver.nil? && INTEGER_RAISING_OPERATORS.include?(call_node.name)
+        end
+
+        def single_argument(call_node)
+          args = call_node.arguments&.arguments || []
+          args.size == 1 ? args.first : nil
+        end
+
+        def integer_rooted_for_diagnostic?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer)
+          when Type::IntegerRange then true
+          when Type::Nominal then type.class_name == "Integer" && type.type_args.empty?
+          else false
+          end
+        end
+
+        def integer_zero_constant?(type)
+          type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.zero?
+        end
+
+        def build_always_raises_diagnostic(path, call_node)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            rule: RULE_ALWAYS_RAISES,
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "always raises ZeroDivisionError: `#{call_node.name}' by zero on Integer receiver",
+            severity: :error
+          )
+        end
+
+        # v0.0.2 #4 — argument-type-mismatch diagnostic.
+        # Walks a call's positional arguments and checks each
+        # against the matching parameter's RBS type via
+        # `Rigor::Inference::Acceptance`. Emits an `:error`
+        # for the first argument whose type the parameter
+        # does NOT accept under the gradual mode.
+        #
+        # Conservative envelope (matches the wrong-arity rule
+        # plus a few additional skips):
+        # - Receiver must be Nominal / Singleton / Constant
+        #   (the same `concrete_class_name` test).
+        # - Method must be in RBS.
+        # - Method must have exactly ONE method type
+        #   (overload). Multi-overload checking is left for
+        #   a follow-up because picking the "intended"
+        #   overload requires the dispatcher's full
+        #   acceptance plumbing.
+        # - The selected overload must have NO
+        #   rest_positionals, NO required keywords, NO
+        #   trailing positionals.
+        # - The call must use plain positional arguments
+        #   (no splat / kw / block-pass / forwarded).
+        # - Per-argument: skip when EITHER side is `Dynamic`
+        #   (the call cannot be statically refuted).
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+        def argument_type_diagnostic(path, call_node, scope_index)
+          return nil if call_node.receiver.nil?
+          return nil unless plain_positional_call?(call_node)
+
+          scope = scope_index[call_node]
+          return nil if scope.nil?
+
+          receiver_type = scope.type_of(call_node.receiver)
+          class_name = concrete_class_name(receiver_type)
+          return nil if class_name.nil?
+
+          # NOTE: unlike the undefined-method / wrong-arity
+          # rules, we deliberately do NOT skip when
+          # `discovered_method?` matches. When the user
+          # supplies BOTH a `def` and an RBS sig, the sig is
+          # the authoritative parameter contract and we
+          # should validate calls against it.
+          loader = scope.environment.rbs_loader
+          return nil if loader.nil?
+          return nil unless loader.class_known?(class_name)
+          return nil unless definition_available?(loader, receiver_type, class_name)
+
+          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          return nil if method_def.nil? || method_def == true
+          return nil unless method_def.method_types.size == 1
+
+          mismatch = first_argument_mismatch(method_def.method_types.first, call_node, scope)
+          return nil if mismatch.nil?
+
+          build_argument_type_diagnostic(path, call_node, class_name, mismatch)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+
+        def first_argument_mismatch(method_type, call_node, scope) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          function = method_type.type
+          return nil unless argument_check_eligible?(function)
+
+          params = function.required_positionals + function.optional_positionals
+          arguments = call_node.arguments&.arguments || []
+          arguments.each_with_index do |arg, index|
+            param = params[index]
+            next if param.nil? # arity mismatch is the wrong-arity rule's concern.
+
+            param_type = translate_param_type(param.type, scope.environment)
+            next if param_type.is_a?(Type::Dynamic) || param_type.is_a?(Type::Top)
+
+            arg_type = scope.type_of(arg)
+            next if arg_type.is_a?(Type::Dynamic) || arg_type.is_a?(Type::Top)
+
+            result = Inference::Acceptance.accepts(param_type, arg_type, mode: :gradual)
+            return { node: arg, name: param.name, expected: param_type, actual: arg_type } if result.no?
+          end
+          nil
+        end
+
+        def argument_check_eligible?(function)
+          # See `arity_eligible?`: `UntypedFunction` lacks
+          # the per-arity accessors. Treat it as ineligible
+          # for argument-type-mismatch diagnostics.
+          return false unless function.respond_to?(:required_keywords)
+
+          function.rest_positionals.nil? &&
+            function.required_keywords.empty? &&
+            function.optional_keywords.empty? &&
+            function.rest_keywords.nil? &&
+            function.trailing_positionals.empty?
+        end
+
+        def translate_param_type(rbs_type, _environment)
+          Inference::RbsTypeTranslator.translate(rbs_type)
+        rescue StandardError
+          Type::Combinator.untyped
+        end
+
+        def build_argument_type_diagnostic(path, call_node, class_name, mismatch)
+          location = mismatch[:node].location
+          method_label = "`#{call_node.name}' on #{class_name}"
+          parameter_label = mismatch[:name] ? "parameter `#{mismatch[:name]}' of #{method_label}" : method_label
+          message = "argument type mismatch at #{parameter_label}: " \
+                    "expected #{mismatch[:expected].describe(:short)}, " \
+                    "got #{mismatch[:actual].describe(:short)}"
+          Diagnostic.new(
+            rule: RULE_ARGUMENT_TYPE,
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: message,
+            severity: :error
+          )
+        end
+
         # rubocop:disable Metrics/ParameterLists
         def build_arity_diagnostic(path, call_node, class_name, min, max, actual)
           location = call_node.message_loc || call_node.location
@@ -475,6 +765,7 @@ module Rigor
           method_label = "`#{call_node.name}' on #{class_name}"
           message = "wrong number of arguments to #{method_label} (given #{actual}, expected #{range})"
           Diagnostic.new(
+            rule: RULE_WRONG_ARITY,
             path: path,
             line: location.start_line,
             column: location.start_column + 1,
@@ -488,6 +779,7 @@ module Rigor
           location = call_node.message_loc || call_node.location
           rendered_receiver = receiver_type.describe
           Diagnostic.new(
+            rule: RULE_UNDEFINED_METHOD,
             path: path,
             line: location.start_line,
             column: location.start_column + 1,

data/lib/rigor/analysis/diagnostic.rb

@@ -3,14 +3,24 @@
 module Rigor
   module Analysis
     class Diagnostic
-      attr_reader :path, :line, :column, :message, :severity
+      attr_reader :path, :line, :column, :message, :severity, :rule
 
-      def initialize(path:, line:, column:, message:, severity: :error)
+      # `rule:` is the stable identifier (a kebab-case string)
+      # of the diagnostic's source rule. It is used by the
+      # configuration and the in-source `# rigor:disable <rule>`
+      # suppression comment system to identify diagnostics by
+      # category. Diagnostics not produced by `CheckRules`
+      # (parse errors, path errors, internal analyzer errors)
+      # may leave `rule` as nil and stay unsuppressible.
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(path:, line:, column:, message:, severity: :error, rule: nil)
+        # rubocop:enable Metrics/ParameterLists
         @path = path
         @line = line
         @column = column
         @message = message
         @severity = severity
+        @rule = rule
       end
 
       def error?
@@ -23,6 +33,7 @@ module Rigor
           "line" => line,
           "column" => column,
           "severity" => severity.to_s,
+          "rule" => rule,
           "message" => message
         }
       end

data/lib/rigor/analysis/runner.rb

@@ -4,18 +4,21 @@ require "prism"
 
 require_relative "../environment"
 require_relative "../scope"
+require_relative "../inference/coverage_scanner"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
 require_relative "diagnostic"
 require_relative "result"
 
 module Rigor
   module Analysis
-    class Runner
+    class Runner # rubocop:disable Metrics/ClassLength
       RUBY_GLOB = "**/*.rb"
 
-      def initialize(configuration:)
+      def initialize(configuration:, explain: false)
         @configuration = configuration
+        @explain = explain
       end
 
       # Walks every Ruby file under `paths`, parses it, builds a
@@ -27,7 +30,13 @@ module Rigor
       # is built once at run start through `Environment.for_project`
       # so all files share the same RBS load.
       def run(paths = @configuration.paths)
-        environment = Environment.for_project
+        Inference::MethodDispatcher::FileFolding.fold_platform_specific_paths =
+          @configuration.fold_platform_specific_paths
+
+        environment = Environment.for_project(
+          libraries: @configuration.libraries,
+          signature_paths: @configuration.signature_paths
+        )
         expansion = expand_paths(paths)
 
         diagnostics = expansion.fetch(:errors)
@@ -73,13 +82,20 @@ module Rigor
         )
       end
 
-      def analyze_file(path, environment)
+      def analyze_file(path, environment) # rubocop:disable Metrics/MethodLength
         parse_result = Prism.parse_file(path)
         return parse_diagnostics(path, parse_result) unless parse_result.errors.empty?
 
         scope = Scope.empty(environment: environment)
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
-        CheckRules.diagnose(path: path, root: parse_result.value, scope_index: index)
+        diagnostics = CheckRules.diagnose(
+          path: path,
+          root: parse_result.value,
+          scope_index: index,
+          comments: parse_result.comments,
+          disabled_rules: @configuration.disabled_rules
+        )
+        diagnostics + explain_diagnostics(path, parse_result.value, scope)
       rescue Errno::ENOENT => e
         [
           Diagnostic.new(
@@ -102,6 +118,37 @@ module Rigor
         ]
       end
 
+      # v0.0.2 #10 — fail-soft fallback explanation. When
+      # `--explain` is set the runner additionally walks the
+      # file with `Rigor::Inference::CoverageScanner` and emits
+      # one `:info` diagnostic per directly-unrecognized node,
+      # naming the node class and the type the engine fell back
+      # to. The CoverageScanner is the canonical "first-event-
+      # per-node" probe: it already filters out pass-through
+      # wrappers (`ProgramNode`, `StatementsNode`,
+      # `ParenthesesNode`) so the explain stream is attributable
+      # to the leaf node that actually triggered the fallback.
+      def explain_diagnostics(path, root, scope)
+        return [] unless @explain
+
+        result = Inference::CoverageScanner.new(scope: scope).scan(root)
+        result.events.map { |event| explain_diagnostic(path, event) }
+      end
+
+      def explain_diagnostic(path, event)
+        location = event.location
+        line = location ? location.start_line : 1
+        column = location ? location.start_column + 1 : 1
+        Diagnostic.new(
+          path: path,
+          line: line,
+          column: column,
+          message: "fail-soft fallback at #{event.node_class}: #{event.inner_type.describe(:short)}",
+          severity: :info,
+          rule: "fallback"
+        )
+      end
+
       def parse_diagnostics(path, parse_result)
         parse_result.errors.map do |error|
           location = error.location

data/lib/rigor/builtins/imported_refinements.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+
+module Rigor
+  module Builtins
+    # Canonical-name registry for the imported-built-in
+    # refinement catalogue. See `imported-built-in-types.md`
+    # in `docs/type-specification/` for the full catalogue
+    # rationale and the kebab-case naming rule.
+    #
+    # Maps kebab-case names (`non-empty-string`, `positive-int`,
+    # `non-empty-array`, …) to the Rigor type each name denotes.
+    # The registry is the single integration point for:
+    #
+    # - The new `rigor:v1:return:` RBS::Extended directive
+    #   ([`Rigor::RbsExtended.read_return_type_override`](../rbs_extended.rb)),
+    #   which overrides a method's RBS-declared return type
+    #   with a refinement carrier.
+    # - Future `RBS::Extended` directives that accept a
+    #   refinement name in any type position (`param:`,
+    #   `assert: x is non-empty-string`, …).
+    # - The display side: `Type::Difference#describe` already
+    #   recognises the same shapes and prints the kebab-case
+    #   spelling without consulting the registry.
+    #
+    # Names not in the registry resolve to `nil`; callers
+    # decide whether to fall back to the RBS-declared type or
+    # raise a parse error.
+    #
+    # The current registry covers no-argument refinement
+    # names. Parameterised refinements like
+    # `non-empty-array[Integer]` will be parsed by a future
+    # tokeniser; today the no-arg form `non-empty-array` lands
+    # at `non_empty_array(top)` and downstream code projects
+    # to the underlying base nominal.
+    module ImportedRefinements
+      REGISTRY = {
+        "non-empty-string" => -> { Type::Combinator.non_empty_string },
+        "non-zero-int" => -> { Type::Combinator.non_zero_int },
+        "non-empty-array" => -> { Type::Combinator.non_empty_array },
+        "non-empty-hash" => -> { Type::Combinator.non_empty_hash },
+        "positive-int" => -> { Type::Combinator.positive_int },
+        "non-negative-int" => -> { Type::Combinator.non_negative_int },
+        "negative-int" => -> { Type::Combinator.negative_int },
+        "non-positive-int" => -> { Type::Combinator.non_positive_int }
+      }.freeze
+      private_constant :REGISTRY
+
+      module_function
+
+      # @param name [String] kebab-case refinement name.
+      # @return [Rigor::Type, nil] the matching refinement
+      #   carrier, or `nil` if the name is not registered.
+      def lookup(name)
+        builder = REGISTRY[name.to_s]
+        builder&.call
+      end
+
+      def known?(name)
+        REGISTRY.key?(name.to_s)
+      end
+
+      def known_names
+        REGISTRY.keys
+      end
+    end
+  end
+end

data/lib/rigor/cli/type_of_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 require "prism"
 
+require_relative "../configuration"
 require_relative "../environment"
 require_relative "../scope"
 require_relative "../source/node_locator"
@@ -47,19 +48,20 @@ module Rigor
       private
 
       def parse_options
-        options = { format: "text", trace: false }
+        options = { format: "text", trace: false, config: Configuration::DEFAULT_PATH }
 
         parser = OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
         end
         parser.parse!(@argv)
 
         options
       end
 
-      def execute(target:, options:)
+      def execute(target:, options:) # rubocop:disable Metrics/AbcSize
         file, line, column = target
         return 1 unless file_exists?(file)
 
@@ -72,7 +74,8 @@ module Rigor
         return 1 if node.nil?
 
         tracer = options[:trace] ? Inference::FallbackTracer.new : nil
-        base_scope = Scope.empty(environment: project_environment(file))
+        configuration = Configuration.load(options.fetch(:config))
+        base_scope = Scope.empty(environment: project_environment(file, configuration))
 
         # Build a per-node scope index so locals bound earlier in the
         # file flow into the scope used to type the queried node. We
@@ -95,8 +98,11 @@ module Rigor
       # walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
       # so probes against files outside the current process's CWD still
       # see the right `sig/` tree.
-      def project_environment(_file)
-        Environment.for_project
+      def project_environment(_file, configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
       end
 
       def file_exists?(file)