rigortype 0.2.9 → 0.3.0

data/lib/rigor/cli/sig_gen_command.rb

@@ -42,21 +42,43 @@ module Rigor
         paths = @argv.empty? ? configuration.paths : @argv
 
         observations = collect_observations(configuration, options)
-        candidates = SigGen::Generator.new(configuration: configuration, paths: paths,
-                                           observations: observations,
-                                           include_private: options.fetch(:include_private)).run
+        generator = SigGen::Generator.new(configuration: configuration, paths: paths,
+                                          observations: observations,
+                                          include_private: options.fetch(:include_private))
+        candidates = generator.run
         mode = options.fetch(:mode).to_sym
 
-        if mode == :write
-          dispatch_write(candidates, configuration, options)
-        else
-          dispatch_print_or_diff(candidates, mode, options)
-        end
-        0
+        status = if mode == :write
+                   dispatch_write(candidates, configuration, options)
+                 else
+                   dispatch_print_or_diff(candidates, mode, options)
+                   0
+                 end
+        report_unrenderable(generator.unrenderable)
+        status
       end
 
       private
 
+      # A method whose rendered RBS does not parse is a Rigor rendering defect, not a fact about the user's
+      # code — the generator skipped it (so the rest of the signatures are still usable and still valid), but
+      # staying silent would leave the user with a quietly incomplete `sig/` and us with an unreported bug.
+      # Reported on stderr so it never contaminates `--print` output being piped into a file.
+      def report_unrenderable(unrenderable)
+        return if unrenderable.empty?
+
+        @err.puts(
+          "rigor sig-gen: skipped #{unrenderable.size} method(s) whose generated RBS does not parse. " \
+          "This is a bug in Rigor's RBS rendering, not in your code — please report it. " \
+          "The remaining signatures are unaffected."
+        )
+        unrenderable.each do |method|
+          @err.puts("  #{method.path}: #{method.class_name}##{method.method_name}")
+          @err.puts("    rendered: #{method.rbs}")
+          @err.puts("    #{method.error}")
+        end
+      end
+
       def dispatch_print_or_diff(candidates, mode, options)
         SigGen::Renderer.new(out: @out).render(
           candidates: candidates,
@@ -66,6 +88,7 @@ module Rigor
         )
       end
 
+      # @return [Integer] exit status — non-zero when a file the user asked to write could not be written.
       def dispatch_write(candidates, configuration, options)
         layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
         path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)
@@ -74,6 +97,10 @@ module Rigor
         results = writer.write_all(candidates)
 
         SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format))
+        # An assembled file that does not parse is refused rather than written. The user asked for a write and
+        # did not get one, so the command must not report success — a green `sig-gen --write` in CI would
+        # otherwise mean nothing.
+        results.any? { |result| result.action == :skipped_invalid_rbs } ? 1 : 0
       end
 
       # Slice 3 — collect call-site argument observations when `--params=observed` is set. When `--observe=PATH` is not

data/lib/rigor/cli/skill_command.rb

@@ -37,9 +37,7 @@ module Rigor
     #                                the SKILL. Also spelled `describe`, and
     #                                surfaced top-level as `rigor describe`.
     #
-    # The pre-v0.3.0 verb spellings `rigor skill list` / `print <name>` / `path <name>` still work but emit a stderr
-    # deprecation notice; they are removed in v0.3.0 (see docs/ROADMAP.md § "Scheduled CLI deprecations"). `describe` is
-    # a no-argument action, not a name-slot verb, so it stays first-class alongside `--describe`.
+    # `describe` is a no-argument action, not a name-slot verb, so it stays first-class alongside `--describe`.
     class SkillCommand < Command
       USAGE = <<~USAGE
         Usage: rigor skill [<name>] [--full <name>] [--path <name>] [--list] [--describe]
@@ -60,30 +58,14 @@ module Rigor
           rigor skill --full rigor-baseline-reduce
           rigor skill --path rigor-baseline-reduce
           rigor skill --describe        (also: rigor describe)
-
-        Deprecated (removed in v0.3.0) — use the forms above:
-          rigor skill list           ->  rigor skill --list
-          rigor skill print <name>   ->  rigor skill <name>
-          rigor skill path <name>    ->  rigor skill --path <name>
       USAGE
 
       # The bundled skills live at `<gem_root>/skills/`. From `lib/rigor/cli/skill_command.rb` that is three directories
       # up.
       SKILLS_ROOT = File.expand_path("../../../skills", __dir__)
 
-      # The verb subcommands the flags superseded keep working with a stderr deprecation notice until this version drops
-      # them. Each maps to the canonical advice printed and the flag it rewrites to.
-      LEGACY_VERB_REMOVAL = "v0.3.0"
-      LEGACY_VERBS = {
-        "list" => { old: "list",         advice: "--list", flag: "--list" },
-        "print" => { old: "print <name>", advice: "<name>", flag: "--print" },
-        "path" => { old: "path <name>", advice: "--path <name>", flag: "--path" }
-      }.freeze
-
       # @return [Integer] CLI exit status.
       def run
-        rewrite_legacy_verb!
-
         case @argv.first
         when nil
           run_list
@@ -112,19 +94,6 @@ module Rigor
 
       private
 
-      # Translate a deprecated verb spelling into its flag form, warning once on stderr, so the dispatch above only
-      # handles canonical forms.
-      def rewrite_legacy_verb!
-        spec = LEGACY_VERBS[@argv.first]
-        return unless spec
-
-        @err.puts(
-          "rigor skill: `#{spec.fetch(:old)}` is deprecated and will be removed in " \
-          "#{LEGACY_VERB_REMOVAL}; use `rigor skill #{spec.fetch(:advice)}` instead."
-        )
-        @argv[0] = spec.fetch(:flag)
-      end
-
       def run_list
         skills = discover_skills
         if skills.empty?

data/lib/rigor/cli/trace_command.rb

@@ -12,6 +12,7 @@ require_relative "../inference/flow_tracer"
 require_relative "../inference/scope_indexer"
 require_relative "command"
 require_relative "trace_renderer"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -90,13 +91,11 @@ module Rigor
         0
       end
 
-      # Mirrors the single-file path `rigor type-of` takes: a project-aware environment, an empty seed scope, one
-      # statement-level evaluation of the whole program — but recorded under the FlowTracer.
+      # Mirrors the single-file path `rigor type-of` takes: the plugin-aware environment (so a trace replays the
+      # same dispatch `rigor check` would, including plugin-synthesized RBS — see {ProbeEnvironment}), an empty
+      # seed scope, one statement-level evaluation of the whole program — but recorded under the FlowTracer.
       def record_events(root, file, configuration)
-        environment = Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+        environment = ProbeEnvironment.build(configuration: configuration, source_files: [file])
         scope = Scope.empty(environment: environment, source_path: file)
         Inference::FlowTracer.record { scope.evaluate(root) }
       end

data/lib/rigor/cli/type_of_command.rb

@@ -13,6 +13,7 @@ require_relative "../inference/scope_indexer"
 require_relative "type_of_renderer"
 require_relative "command"
 require_relative "options"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -92,14 +93,14 @@ module Rigor
         0
       end
 
-      # Builds a project-aware environment relative to the probed file. Project-RBS auto-detection roots at CWD today;
-      # future work will 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, configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+      # Builds the plugin-aware environment relative to the probed file, so the reported type matches what `rigor
+      # check` computes for the same position — including types synthesized from inline RBS annotations by the
+      # ADR-93 auto-wired `rigor-rbs-inline` plugin (see {ProbeEnvironment} for the #162 misattribution this
+      # closes). The probed file is threaded as the synthesizer's `source_files:`. Project-RBS auto-detection
+      # roots at CWD today; future work will 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, configuration)
+        ProbeEnvironment.build(configuration: configuration, source_files: [file])
       end
 
       def file_exists?(file)

data/lib/rigor/cli/type_scan_command.rb

@@ -11,6 +11,7 @@ require_relative "../scope"
 require_relative "type_scan_renderer"
 require_relative "type_scan_report"
 require_relative "command"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -69,20 +70,19 @@ module Rigor
 
       def scan_paths(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration))
+        scope = Scope.empty(environment: project_environment(configuration, paths))
         scanner = Inference::CoverageScanner.new(scope: scope)
         accumulator = ScanAccumulator.new
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
         accumulator.to_report(paths, options)
       end
 
-      # Builds a project-aware environment that auto-detects `<cwd>/sig` by default and honours the configuration's
-      # `libraries:` / `signature_paths:` keys when present.
-      def project_environment(configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+      # Builds the plugin-aware environment that auto-detects `<cwd>/sig` by default and honours the
+      # configuration's `libraries:` / `signature_paths:` keys when present. The scanned `paths` are threaded as
+      # the plugin `source_rbs_synthesizer` inputs so coverage reflects the same synthesized RBS `rigor check`
+      # sees (see {ProbeEnvironment}).
+      def project_environment(configuration, source_files)
+        ProbeEnvironment.build(configuration: configuration, source_files: source_files)
       end
 
       def scan_one(path, scanner, accumulator, configuration)

data/lib/rigor/cli.rb

@@ -11,7 +11,7 @@ require_relative "analysis/diagnostic"
 require_relative "analysis/result"
 require_relative "cli/options"
 require_relative "cli/diagnostic_formats"
-require_relative "cli/ci_detector"
+require_relative "ci_detector"
 
 module Rigor
   # The CLI class is a dispatcher: each `run_*` method delegates to a command-specific class once the command grows
@@ -20,6 +20,16 @@ module Rigor
   class CLI # rubocop:disable Metrics/ClassLength
     EXIT_USAGE = 64
 
+    # The published location of `schemas/rigor-config.schema.json`, written into the `.rigor.yml` that
+    # `rigor init` generates so an editor validates the file as the user types.
+    #
+    # This MUST equal the schema's own `$id`, and it MUST resolve. Both are gated
+    # (`spec/rigor/config_schema_spec.rb`) because neither failure has a symptom: an unreachable schema
+    # is indistinguishable from a schema with no complaints, so a stale URL here silently disables
+    # validation for every project that ran `rigor init`. It pointed at a nonexistent org until
+    # 2026-07-17 and nothing noticed. See `docs/internal-spec/config.md`.
+    CONFIG_SCHEMA_URL = "https://github.com/rigortype/rigor/raw/master/schemas/rigor-config.schema.json"
+
     HANDLERS = {
       "check" => :run_check,
       "init" => :run_init,
@@ -138,9 +148,10 @@ module Rigor
     # most likely to want to edit.
     def init_template
       <<~YAML
-        # yaml-language-server: $schema=https://github.com/zenwerk/rigor/raw/master/schemas/rigor-config.schema.json
-        # Rigor configuration. See docs/CURRENT_WORK.md for the
-        # full set of features the analyzer ships in this preview.
+        # yaml-language-server: $schema=#{CONFIG_SCHEMA_URL}
+        # Rigor configuration. The full key reference is
+        # https://github.com/rigortype/rigor/blob/master/docs/manual/03-configuration.md
+        # (or run `rigor docs configuration`).
         #
         # Keys you may want to edit:
         # - target_ruby: minimum Ruby version your project targets.

data/lib/rigor/config_audit.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
+require "did_you_mean"
+
 require_relative "signature_path_audit"
-require_relative "analysis/check_rules"
+# ADR-87 WD4 — only the pure rule-id table (`ALL_RULES` / `RULE_FAMILIES`) is needed, so require the light
+# `rule_ids.rb` rather than the engine-pulling `check_rules.rb`; keeps `config_audit` (loaded by every check)
+# off the inference engine so the boot-slimming hit path stays engine-free.
+require_relative "analysis/check_rules/rule_ids"
 
 module Rigor
   # Audits a loaded {Configuration} for the class of mistake where a configured value
@@ -36,12 +41,53 @@ module Rigor
     #   paths resolve against (the CLI's CWD), used only by the explicit-path checks.
     # @return [Array<Warning>]
     def self.warnings(configuration, project_root: Dir.pwd)
-      signature_path_warnings(configuration) +
+      unknown_key_warnings(configuration) +
+        signature_path_warnings(configuration) +
         library_warnings(configuration) +
         rule_token_warnings(configuration) +
         explicit_path_warnings(configuration, project_root)
     end
 
+    # Top-level keys the loader does not own. The archetypal case is a typo — `excludee:` for
+    # `exclude:` — which the loader drops in silence, so the exclusion never applies and the run
+    # reports errors from the very files the user meant to skip, with nothing anywhere saying the key
+    # did nothing. That is exactly this module's class of mistake, and it was the one whole-key
+    # instance of it going unwarned.
+    #
+    # A reserved namespace ({Configuration::RESERVED_NAMESPACES}) is unknown *on purpose* — another
+    # implementation reads it from the same file — so it is exempt. {Configuration#unknown_keys}
+    # already applies that exemption; warning here would push users to delete the key their other
+    # tool needs.
+    #
+    # **Top level only, and deliberately.** A nested check would have to name each group's known keys,
+    # and DEFAULTS cannot supply them: `DEFAULTS["dependencies"]` carries `source_inference` and
+    # `budget_per_gem` but not `budget_overrun_strategy`, which is real (`Configuration::Dependencies`
+    # reads it), documented, and schema-declared — so a DEFAULTS-keyed nested check would flag a
+    # working config. `severity_overrides:` is an open map of rule ids besides. Nested unknown keys are
+    # the schema tier's job: every nested object in `schemas/rigor-config.schema.json` is
+    # `additionalProperties: false`, and `config_schema_spec` keeps it complete
+    # ([ADR-99](../../docs/adr/99-config-schema-authority.md), `docs/internal-spec/config.md`).
+    def self.unknown_key_warnings(configuration)
+      configuration.unknown_keys.map do |key|
+        suggestion = suggest_config_key(key)
+        hint = suggestion ? " Did you mean `#{suggestion}`?" : ""
+        Warning.new(
+          kind: :unknown_key,
+          message: "`#{key}` is not a recognized configuration key; it has no effect.#{hint}",
+          fields: { "key" => key, "suggestion" => suggestion }
+        )
+      end
+    end
+
+    # Nearest known key, or nil. Uses `DidYouMean::SpellChecker` — the engine behind Ruby's own
+    # `NoMethodError` hints, and the one `Plugin::Base.suggest` wraps. Called directly rather than
+    # through that helper because `plugin/base.rb` pulls Prism and the diagnostic model in, and
+    # ADR-87 WD4 keeps this file (loaded by every check) off that path; `did_you_mean` is stdlib.
+    def self.suggest_config_key(key)
+      DidYouMean::SpellChecker.new(dictionary: Configuration::KNOWN_KEYS).correct(key.to_s).first
+    end
+    private_class_method :suggest_config_key
+
     # `signature_paths:` entries that resolve to nothing — delegated to {SignaturePathAudit},
     # which mirrors the loader's `directory?` + recursive `**/*.rbs` acceptance test.
     def self.signature_path_warnings(configuration)

data/lib/rigor/configuration/severity_profile.rb

@@ -37,11 +37,15 @@ module Rigor
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :warning,
           "call.possible-nil-receiver" => :warning,
+          "call.raise-non-exception" => :warning,
           "flow.always-raises" => :warning,
           "flow.unreachable-branch" => :info,
           "flow.dead-assignment" => :info,
           "flow.always-truthy-condition" => :info,
           "flow.unreachable-clause" => :info,
+          "flow.duplicate-hash-key" => :info,
+          "flow.return-in-ensure" => :info,
+          "flow.shadowed-rescue-clause" => :info,
           "assert.type-mismatch" => :error,
           "dump.type" => :info,
           "def.return-type-mismatch" => :warning,
@@ -50,6 +54,16 @@ module Rigor
           "def.override-return-widened" => :off,
           "def.override-param-narrowed" => :off,
           "def.ivar-write-mismatch" => :warning,
+          # ADR-8 companion (PHPStan IgnoreParseErrorRule-modelled): a broken suppression comment is
+          # equally bad in every profile — it silently fails to do what the author believes it does — so
+          # both rules stay :warning across all three profiles (including strict).
+          "suppression.unknown-rule" => :warning,
+          "suppression.empty" => :warning,
+          "suppression.unknown-marker" => :warning,
+          # ADR-100 — a new required diagnostic (ADR-50 WD1), so it is `:off` in every shipped profile and
+          # reaches a user only through the `use-of-void-value` bleeding-edge feature, which overrides this
+          # to `:warning`.
+          "static.value-use.void" => :off,
           # Opt-in author assertion: you only see it if you wrote a
           # `conforms-to` directive, so it stays a :warning even in
           # lenient — it is never unsolicited noise.
@@ -62,6 +76,7 @@ module Rigor
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
+          "call.raise-non-exception" => :error,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :warning,
           "flow.dead-assignment" => :warning,
@@ -71,6 +86,9 @@ module Rigor
           # green; promote to :warning once Mastodon/GitLab/Redmine triage
           # to zero net false positives.
           "flow.unreachable-clause" => :info,
+          "flow.duplicate-hash-key" => :warning,
+          "flow.return-in-ensure" => :warning,
+          "flow.shadowed-rescue-clause" => :warning,
           "assert.type-mismatch" => :error,
           "dump.type" => :info,
           "def.return-type-mismatch" => :warning,
@@ -79,6 +97,10 @@ module Rigor
           "def.override-return-widened" => :warning,
           "def.override-param-narrowed" => :warning,
           "def.ivar-write-mismatch" => :warning,
+          "suppression.unknown-rule" => :warning,
+          "suppression.empty" => :warning,
+          "suppression.unknown-marker" => :warning,
+          "static.value-use.void" => :off,
           "rbs_extended.unsatisfied-conformance" => :warning
         }.freeze,
         strict: {
@@ -88,6 +110,7 @@ module Rigor
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
+          "call.raise-non-exception" => :error,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :error,
           "flow.dead-assignment" => :error,
@@ -96,6 +119,9 @@ module Rigor
           # below its :error siblings) while it proves out — see the
           # balanced-profile note above.
           "flow.unreachable-clause" => :warning,
+          "flow.duplicate-hash-key" => :error,
+          "flow.return-in-ensure" => :error,
+          "flow.shadowed-rescue-clause" => :error,
           "assert.type-mismatch" => :error,
           "dump.type" => :error,
           "def.return-type-mismatch" => :error,
@@ -104,6 +130,11 @@ module Rigor
           "def.override-return-widened" => :error,
           "def.override-param-narrowed" => :error,
           "def.ivar-write-mismatch" => :error,
+          "suppression.unknown-rule" => :warning,
+          "suppression.empty" => :warning,
+          "suppression.unknown-marker" => :warning,
+          # `:off` even under strict: the gate is `bleeding_edge:`, not the profile (ADR-50 WD1 / ADR-100).
+          "static.value-use.void" => :off,
           "rbs_extended.unsatisfied-conformance" => :error
         }.freeze
       }.freeze