rigortype 0.1.8 → 0.1.10

data/lib/rigor/cli.rb

@@ -21,14 +21,17 @@ module Rigor
     HANDLERS = {
       "check" => :run_check,
       "init" => :run_init,
+      "annotate" => :run_annotate,
       "type-of" => :run_type_of,
       "type-scan" => :run_type_scan,
       "explain" => :run_explain,
       "diff" => :run_diff,
       "sig-gen" => :run_sig_gen,
       "lsp" => :run_lsp,
+      "mcp" => :run_mcp,
       "baseline" => :run_baseline,
-      "triage" => :run_triage
+      "triage" => :run_triage,
+      "coverage" => :run_coverage
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -80,7 +83,7 @@ module Rigor
       buffer = resolve_buffer_binding(options)
       return EXIT_USAGE if buffer == :usage_error
 
-      configuration = Configuration.load(options.fetch(:config))
+      configuration = load_check_configuration(options)
       cache_root = configuration.cache_path
       handle_clear_cache(cache_root) if options.fetch(:clear_cache)
 
@@ -88,13 +91,56 @@ module Rigor
         configuration: configuration, options: options,
         buffer: buffer, cache_root: cache_root
       )
-      result = runner.run(@argv.empty? ? configuration.paths : @argv)
-      result = apply_baseline_filter(result, configuration, options)
+      raw_result = runner.run(@argv.empty? ? configuration.paths : @argv)
+      result = apply_baseline_filter(raw_result, configuration, options)
 
       write_result(result, options.fetch(:format))
       write_run_stats(result.stats) if result.stats
       write_cache_stats(cache_root, runner.cache_store) if options.fetch(:cache_stats)
-      result.success? ? 0 : 1
+
+      exit_code = result.success? ? 0 : 1
+      exit_code = 1 if baseline_strict_violation?(raw_result.diagnostics, configuration, options)
+      exit_code
+    end
+
+    # ADR-22 slice 5 — the `--baseline-strict` CI gate. When the
+    # flag is set, ANY baseline drift fails the run — not only
+    # excess drift (a bucket over threshold, which already fails
+    # via the surfaced diagnostics) but also DEFICIT drift
+    # (`actual < count`: the baseline has grown looser than the
+    # code and should be regenerated). A no-op, with a stderr
+    # note, when no baseline is active — the flag never
+    # implicitly loads a baseline the config did not name (WD2).
+    def baseline_strict_violation?(raw_diagnostics, configuration, options)
+      return false unless options.fetch(:baseline_strict)
+
+      path = resolve_baseline_path(configuration, options)
+      if path.nil?
+        @err.puts("rigor: --baseline-strict given but no baseline is active; nothing to gate.")
+        return false
+      end
+
+      baseline = Analysis::Baseline.load(path)
+      return false if baseline.nil? || baseline.empty?
+
+      drifted = baseline.audit(raw_diagnostics).reject { |row| row.status == :within }
+      return false if drifted.empty?
+
+      report_strict_drift(drifted, path)
+      true
+    rescue Analysis::Baseline::LoadError => e
+      @err.puts("rigor: baseline load failed: #{e.message} (--baseline-strict gate skipped)")
+      false
+    end
+
+    def report_strict_drift(rows, path)
+      @err.puts("rigor: --baseline-strict — #{rows.size} bucket(s) drifted from #{path}:")
+      rows.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+        delta = row.delta.positive? ? "+#{row.delta}" : row.delta.to_s
+        @err.puts("  #{row.bucket.file}  [#{row.bucket.rule}]  " \
+                  "#{row.bucket.count} → #{row.actual_count}  (Δ#{delta}, #{row.status})")
+      end
+      @err.puts("rigor: run `rigor baseline regenerate` to refresh the baseline.")
     end
 
     # ADR-22 — apply the baseline filter as the LAST step of
@@ -234,7 +280,19 @@ module Rigor
         # to `.rigor.yml`'s `baseline:` key"; a String overrides
         # the config; `false` (from `--no-baseline`) suppresses
         # any baseline that the config might name.
-        baseline: :unset
+        baseline: :unset,
+        # ADR-22 slice 5 — `--baseline-strict` CI gate: fail the
+        # run on any baseline drift, in either direction.
+        baseline_strict: false,
+        # ADR-32 WD10 carry-over — `--treat-all-as-inline-rbs`
+        # forces the `rigor-rbs-inline` plugin into the loaded
+        # plugin set with `require_magic_comment: false` so a
+        # single ad-hoc `rigor check` invocation treats every
+        # analysed file as inline-RBS without the user editing
+        # `.rigor.yml`. Intended for single-file / ad-hoc CI use;
+        # ordinary projects should configure the plugin in
+        # `.rigor.yml`.
+        treat_all_as_inline_rbs: false
       }
       parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = "Usage: rigor check [options] [paths]"
@@ -268,11 +326,60 @@ module Rigor
                 "ADR-22: ignore any configured baseline for this run") do
           options[:baseline] = false
         end
+        opts.on("--baseline-strict",
+                "ADR-22: fail the run on any baseline drift (CI gate)") do
+          options[:baseline_strict] = true
+        end
+        opts.on("--treat-all-as-inline-rbs",
+                "ADR-32: force-load rigor-rbs-inline with require_magic_comment: false") do
+          options[:treat_all_as_inline_rbs] = true
+        end
       end
       parser.parse!(@argv)
       options
     end
 
+    # ADR-32 WD10 carry-over — wraps `Configuration.load` so the
+    # CLI's `--treat-all-as-inline-rbs` flag can inject a
+    # `rigor-rbs-inline` plugin entry with
+    # `require_magic_comment: false` into the loaded plugin
+    # set. Re-runs the include-aware YAML load and applies the
+    # injection before `Configuration.new` so the new entry
+    # follows the normal coercion path. A pre-existing
+    # `rigor-rbs-inline` entry (by gem name or `id: rbs-inline`)
+    # is removed first so the synthesised entry's
+    # `require_magic_comment: false` wins unconditionally.
+    def load_check_configuration(options)
+      return Configuration.load(options.fetch(:config)) unless options.fetch(:treat_all_as_inline_rbs)
+
+      path = options.fetch(:config) || Configuration.discover
+      data = path && File.exist?(path) ? Configuration.load_with_includes(path) : {}
+      data = data.dup
+      data["plugins"] = inject_treat_all_as_inline_rbs(Array(data["plugins"]))
+      Configuration.new(Configuration::DEFAULTS.merge(data))
+    end
+
+    def inject_treat_all_as_inline_rbs(entries)
+      filtered = entries.reject { |entry| rigor_rbs_inline_entry?(entry) }
+      filtered + [{
+        "gem" => "rigor-rbs-inline",
+        "id" => "rbs-inline",
+        "config" => { "require_magic_comment" => false }
+      }]
+    end
+
+    def rigor_rbs_inline_entry?(entry)
+      case entry
+      when String
+        entry == "rigor-rbs-inline"
+      when Hash
+        string_keyed = entry.to_h { |k, v| [k.to_s, v] }
+        string_keyed["gem"] == "rigor-rbs-inline" || string_keyed["id"] == "rbs-inline"
+      else
+        false
+      end
+    end
+
     def handle_clear_cache(cache_root)
       if File.directory?(cache_root)
         FileUtils.rm_rf(cache_root)
@@ -423,6 +530,12 @@ module Rigor
       YAML
     end
 
+    def run_annotate
+      require_relative "cli/annotate_command"
+
+      AnnotateCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_type_of
       require_relative "cli/type_of_command"
 
@@ -459,6 +572,12 @@ module Rigor
       LspCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_mcp
+      require_relative "cli/mcp_command"
+
+      McpCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_baseline
       require_relative "cli/baseline_command"
 
@@ -471,6 +590,12 @@ module Rigor
       CLI::TriageCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_coverage
+      require_relative "cli/coverage_command"
+
+      CLI::CoverageCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -506,13 +631,16 @@ module Rigor
         Commands:
           check      Analyze Ruby source files
           init       Create a starter .rigor.yml
+          annotate   Print FILE with each line's last-expression type
           type-of    Print the inferred type at FILE:LINE:COL
           type-scan  Report Scope#type_of coverage across PATHs
           explain    Print the description of one or all CheckRules
           diff       Compare current diagnostics to a saved baseline JSON
           sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
           lsp        Run the Rigor Language Server (LSP) over stdio
+          mcp        Run the Rigor MCP server over stdio (ADR-33)
           triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
+          coverage   Report type-precision coverage (precise vs Dynamic ratio)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/environment/rbs_loader.rb

@@ -56,7 +56,7 @@ module Rigor
         # run. The gem stubs are intentionally read-only and
         # appended LAST so user-supplied `signature_paths` win on
         # name conflicts.
-        def build_env_for(libraries:, signature_paths:)
+        def build_env_for(libraries:, signature_paths:, virtual_rbs: [])
           rbs_loader = RBS::EnvironmentLoader.new
           libraries.each do |library|
             next unless rbs_loader.has_library?(library: library, version: nil)
@@ -70,7 +70,36 @@ module Rigor
           vendored_gem_sig_paths.each do |path|
             rbs_loader.add(path: path) if path.directory?
           end
-          RBS::Environment.from_loader(rbs_loader).resolve_type_names
+          env = RBS::Environment.from_loader(rbs_loader)
+          add_virtual_rbs(env, virtual_rbs)
+          env.resolve_type_names
+        end
+
+        # ADR-32 WD4 — merge synthesised-from-source RBS strings
+        # into the freshly-built environment. Each entry is a
+        # `[virtual_filename, rbs_source]` pair. `virtual_filename`
+        # is purely for diagnostic provenance (RBS parse errors
+        # cite it) — it is not a real file path. Per WD6 the
+        # synthesizer-emit path is responsible for catching its
+        # own parse errors and returning `nil` rather than
+        # garbage; this method assumes its input is parseable
+        # and only rescues `RBS::ParsingError` as a fail-soft.
+        def add_virtual_rbs(env, virtual_rbs)
+          return if virtual_rbs.nil? || virtual_rbs.empty?
+
+          virtual_rbs.each do |filename, content|
+            next if content.nil? || content.empty?
+
+            buffer = ::RBS::Buffer.new(name: filename.to_s, content: content.to_s)
+            _, directives, decls = ::RBS::Parser.parse_signature(buffer)
+            source = ::RBS::Source::RBS.new(buffer, directives || [], decls || [])
+            env.add_source(source)
+          rescue ::RBS::BaseError
+            # WD6 fail-soft: a single broken virtual RBS contribution
+            # does not pull the whole env down. The plugin layer
+            # records a `source-rbs-synthesis-failed` info diagnostic
+            # in slice 2; here we just skip the entry.
+          end
         end
 
         # Per-gem `data/vendored_gem_sigs/<gem>/` directories that
@@ -95,7 +124,7 @@ module Rigor
         end
       end
 
-      attr_reader :libraries, :signature_paths, :cache_store
+      attr_reader :libraries, :signature_paths, :cache_store, :virtual_rbs
 
       # @param libraries [Array<String, Symbol>] stdlib library names to
       #   load on top of core (e.g., `["pathname", "json"]`). Empty by
@@ -114,10 +143,18 @@ module Rigor
       #   reflection artefacts). Pass `nil` (the default) to skip
       #   the cache entirely; the runner threads its own Store
       #   through here when caching is enabled.
-      def initialize(libraries: [], signature_paths: [], cache_store: nil)
+      # @param virtual_rbs [Array<[String, String]>] ADR-32 WD4 —
+      #   `[virtual_filename, rbs_source]` pairs synthesised from
+      #   project source by a plugin's
+      #   `Manifest#source_rbs_synthesizer`. Merged into the env
+      #   after `signature_paths:` and the vendored stubs. Pass
+      #   `[]` (the default) when no synthesizer-emitting plugin
+      #   is loaded.
+      def initialize(libraries: [], signature_paths: [], cache_store: nil, virtual_rbs: [])
         @libraries = libraries.map(&:to_s).freeze
         @signature_paths = signature_paths.map { |p| Pathname(p) }.freeze
         @cache_store = cache_store
+        @virtual_rbs = virtual_rbs.map { |name, content| [name.to_s.dup.freeze, content.to_s.dup.freeze].freeze }.freeze
         # Per-loader memoization bucket. Held as a single
         # mutable Hash so the loader instance itself can be
         # `.freeze`d (per ADR-15 reflection-facade contract)
@@ -642,7 +679,11 @@ module Rigor
       end
 
       def build_env
-        self.class.build_env_for(libraries: @libraries, signature_paths: @signature_paths)
+        self.class.build_env_for(
+          libraries: @libraries,
+          signature_paths: @signature_paths,
+          virtual_rbs: @virtual_rbs
+        )
       end
 
       def build_instance_definition(class_name)

data/lib/rigor/environment/reporters.rb

@@ -29,11 +29,12 @@ module Rigor
     # return nil, and the consumer sites short-circuit on
     # `reporter.nil?`.
     class Reporters
-      attr_accessor :rbs_extended, :boundary_cross
+      attr_accessor :rbs_extended, :boundary_cross, :source_rbs_synthesis
 
-      def initialize(rbs_extended: nil, boundary_cross: nil)
+      def initialize(rbs_extended: nil, boundary_cross: nil, source_rbs_synthesis: nil)
         @rbs_extended = rbs_extended
         @boundary_cross = boundary_cross
+        @source_rbs_synthesis = source_rbs_synthesis
       end
     end
   end

data/lib/rigor/environment.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
 require_relative "environment/reflection"
@@ -24,7 +26,7 @@ module Rigor
   # constant-folding tiers cannot answer.
   #
   # See docs/internal-spec/inference-engine.md for the binding contract.
-  class Environment
+  class Environment # rubocop:disable Metrics/ClassLength
     DEFAULT_PROJECT_SIG_DIR = "sig"
     private_constant :DEFAULT_PROJECT_SIG_DIR
 
@@ -87,6 +89,7 @@ module Rigor
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil, # rubocop:disable Metrics/ParameterLists
                    plugin_registry: nil, dependency_source_index: nil,
                    rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                   source_rbs_synthesis_reporter: nil,
                    synthetic_method_index: nil, project_patched_methods: nil,
                    hkt_registry: nil)
       @class_registry = class_registry
@@ -100,7 +103,8 @@ module Rigor
       # accessors below preserve the public lookup shape.
       @reporters = Reporters.new(
         rbs_extended: rbs_extended_reporter,
-        boundary_cross: boundary_cross_reporter
+        boundary_cross: boundary_cross_reporter,
+        source_rbs_synthesis: source_rbs_synthesis_reporter
       )
       @synthetic_method_index = synthetic_method_index || Inference::SyntheticMethodIndex::EMPTY
       @project_patched_methods = project_patched_methods || Inference::ProjectPatchedMethods::EMPTY
@@ -159,6 +163,17 @@ module Rigor
       @reporters.boundary_cross
     end
 
+    # ADR-32 WD6 — the per-run accumulator for synthesizer
+    # failure events. `Environment.for_project` records
+    # `[:error, message]` returns from a plugin's
+    # `source_rbs_synthesizer` here so the Runner can emit
+    # `source-rbs-synthesis-failed` `:info` diagnostics after
+    # analysis completes. Nil when no plugin contributes a
+    # synthesizer.
+    def source_rbs_synthesis_reporter
+      @reporters.source_rbs_synthesis
+    end
+
     # Replaces the env's per-run reporter slots. Intended for
     # long-lived integrations (LSP `ProjectContext`) that share one
     # Environment instance across many `Runner.run` calls: each call
@@ -210,10 +225,12 @@ module Rigor
       def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
                       plugin_registry: nil, dependency_source_index: nil,
                       rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                      source_rbs_synthesis_reporter: nil,
                       bundler_bundle_path: nil, bundler_auto_detect: false,
                       bundler_lockfile: nil,
                       rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
-                      synthetic_method_index: nil, project_patched_methods: nil)
+                      synthetic_method_index: nil, project_patched_methods: nil,
+                      source_files: [])
         resolved_paths = signature_paths || default_signature_paths(root)
         # O4 MVP — append per-gem `sig/` directories discovered
         # under the target project's bundler install root. Empty
@@ -252,12 +269,39 @@ module Rigor
           project_root: root,
           auto_detect: rbs_collection_auto_detect
         ).map(&:to_s)
-        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
+        # ADR-25 — RBS signature directories contributed by loaded
+        # plugins via their manifest `signature_paths:`. Resolved
+        # to absolute dirs by `Plugin::Base#signature_paths`;
+        # additive, ranked below the user's explicit
+        # `signature_paths:` and above the opportunistic bundle /
+        # collection discovery. A duplicate-declaration conflict
+        # degrades through the same O7 failure-memo path.
+        plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
+        loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
+        # ADR-32 WD4 + WD5 — invoke each loaded plugin's
+        # `source_rbs_synthesizer` once per project source file
+        # and collect non-nil `[filename, rbs_source]` pairs.
+        # The synthesizer-emitting plugin (currently only
+        # `rigor-rbs-inline`) is responsible for its own
+        # fail-soft on parse errors per WD6; this loop only
+        # filters `nil` returns.
+        #
+        # When a `cache_store` is supplied, each synthesizer
+        # invocation is memoised per
+        # `(file path + content SHA, plugin id + version + config_hash)`
+        # — WD5's cache key — so a second run with unchanged
+        # source skips the rbs-inline parse cost. The empty
+        # string is the sentinel for "no contribution" so the
+        # Store (which treats `nil` as cache miss) can persist
+        # the no-contribution decision too.
+        virtual_rbs = collect_virtual_rbs(plugin_registry, source_files, cache_store,
+                                          source_rbs_synthesis_reporter)
         loader = RbsLoader.new(
           libraries: merged_libraries,
           signature_paths: loader_signature_paths,
-          cache_store: cache_store
+          cache_store: cache_store,
+          virtual_rbs: virtual_rbs
         )
         # ADR-20 slice 2c + 2e — seed hkt_registry with the
         # bundled builtins. The Environment's `#hkt_registry`
@@ -274,6 +318,7 @@ module Rigor
           dependency_source_index: dependency_source_index,
           rbs_extended_reporter: rbs_extended_reporter,
           boundary_cross_reporter: boundary_cross_reporter,
+          source_rbs_synthesis_reporter: source_rbs_synthesis_reporter,
           synthetic_method_index: synthetic_method_index,
           project_patched_methods: project_patched_methods,
           hkt_registry: Builtins::HktBuiltins.registry
@@ -287,6 +332,124 @@ module Rigor
         sig = Pathname(root) / DEFAULT_PROJECT_SIG_DIR
         sig.directory? ? [sig] : []
       end
+
+      # ADR-32 WD4 + WD5 — for each project source file, invoke
+      # every plugin-registered synthesizer once and collect
+      # non-nil returns. The returned array is `[[virtual_filename,
+      # rbs_source], ...]`; the loader threads it through to
+      # `RbsLoader.new(virtual_rbs: ...)`.
+      #
+      # `virtual_filename` is the source file path prefixed with
+      # the plugin id so RBS parse errors point back to the
+      # contributing plugin in their diagnostic location string.
+      #
+      # When no plugin declares a synthesizer (the common case),
+      # the registry's `source_rbs_synthesizers` is empty and
+      # this method short-circuits to `[]` without walking the
+      # file list.
+      #
+      # WD5 — when `cache_store` is supplied, each (file, plugin)
+      # synthesizer call is memoised through `Cache::Store`. The
+      # cache key composes the file's content SHA with the
+      # plugin's `PluginEntry` (id + version + config_hash) so a
+      # config change or content change invalidates the entry
+      # automatically.
+      def collect_virtual_rbs(plugin_registry, source_files, cache_store, reporter)
+        return [] if plugin_registry.nil?
+
+        synthesizers = plugin_registry.source_rbs_synthesizers
+        return [] if synthesizers.empty?
+        return [] if source_files.nil? || source_files.empty?
+
+        result = []
+        source_files.each do |path|
+          synthesizers.each do |plugin, callable|
+            outcome = synthesizer_output_for(plugin, callable, path, cache_store)
+            outcome = interpret_synthesizer_outcome(outcome, plugin, path, reporter)
+            next if outcome.nil? || outcome.empty?
+
+            virtual_name = "virtual:#{plugin.manifest.id}:#{path}"
+            result << [virtual_name, outcome]
+          end
+        end
+        result
+      end
+
+      # ADR-32 WD5 — cache wrapper around a single (plugin,
+      # file) invocation. The cache stores the empty string
+      # `""` as the "no contribution" sentinel because
+      # `Cache::Store` treats `nil` as a cache miss. Error
+      # tuples are stored as the canonical
+      # `[:error, message_string]` Array so the same wrapper
+      # short-circuits subsequent runs against unchanged broken
+      # input.
+      def synthesizer_output_for(plugin, callable, path, cache_store)
+        return invoke_synthesizer_safely(callable, path) if cache_store.nil?
+        return invoke_synthesizer_safely(callable, path) unless File.file?(path)
+
+        descriptor = build_synthesizer_cache_descriptor(plugin, path)
+        cache_store.fetch_or_compute(
+          producer_id: SYNTHESIZER_CACHE_PRODUCER_ID,
+          params: {},
+          descriptor: descriptor
+        ) { invoke_synthesizer_safely(callable, path) || "" }
+      end
+
+      # ADR-32 WD6 — route a synthesizer return value through
+      # the per-run failure reporter. The synthesizer's contract
+      # (declared in `plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb`)
+      # admits three return shapes:
+      #   - `String` (non-empty) → successful RBS source
+      #   - `nil` / `""`         → no contribution
+      #   - `[:error, message]`  → parse failed
+      # The error tuple is converted into a reporter entry +
+      # treated as "no contribution" so the analysis pipeline
+      # continues. Reporter is `nil` for callers that don't care
+      # (legacy Environment.new, tests).
+      def interpret_synthesizer_outcome(outcome, plugin, path, reporter)
+        return outcome unless outcome.is_a?(Array) && outcome[0] == :error
+
+        reporter&.record(
+          plugin_id: plugin.manifest.id,
+          path: path,
+          message: outcome[1].to_s
+        )
+        nil
+      end
+
+      SYNTHESIZER_CACHE_PRODUCER_ID = "plugin.source_rbs_synthesizer"
+      private_constant :SYNTHESIZER_CACHE_PRODUCER_ID
+
+      def build_synthesizer_cache_descriptor(plugin, path)
+        Cache::Descriptor.new(
+          files: [Cache::Descriptor::FileEntry.new(
+            path: path.to_s,
+            comparator: :digest,
+            value: synthesizer_input_digest(path)
+          )],
+          plugins: [plugin.plugin_entry]
+        )
+      end
+
+      def synthesizer_input_digest(path)
+        Digest::SHA256.hexdigest(File.binread(path))
+      rescue ::SystemCallError
+        # Unreadable file → key on the path alone; the
+        # synthesizer's File.file?/File.read will see the same
+        # failure and return nil.
+        Digest::SHA256.hexdigest(path.to_s)
+      end
+
+      def invoke_synthesizer_safely(callable, path)
+        callable.call(path.to_s)
+      rescue StandardError
+        # WD6 fail-soft — a synthesizer that raises does NOT
+        # crash analysis. Slice 2b will turn this into a
+        # `source-rbs-synthesis-failed` info diagnostic; for now
+        # the contract is "no analysis crash on a misbehaving
+        # synthesizer".
+        nil
+      end
     end
 
     # Resolves a constant name to a Rigor::Type::Nominal (the *instance*

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -57,7 +57,8 @@ module Rigor
           return nil unless klass
 
           bucket_key = kind == :singleton ? "singleton_methods" : "instance_methods"
-          klass.dig(bucket_key, selector.to_s)
+          klass.dig(bucket_key, selector.to_s) ||
+            resolve_alias_entry(klass, selector, bucket_key)
         end
 
         def reset!
@@ -66,6 +67,21 @@ module Rigor
 
         private
 
+        def resolve_alias_entry(klass, selector, bucket_key)
+          return nil unless bucket_key == "instance_methods"
+
+          aliases = klass["aliases"]
+          return nil unless aliases
+
+          alias_entry = aliases[selector.to_s]
+          return nil unless alias_entry
+
+          target = alias_entry["old"]
+          return nil unless target
+
+          klass.dig(bucket_key, target)
+        end
+
         def blocked?(class_name, selector)
           # Bang-suffixed selectors are mutating by Ruby convention
           # (`upcase!`, `concat`, etc. are listed explicitly below;

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -55,7 +55,16 @@ module Rigor
             # as `time_localtime`: `time_modify(time)` then a
             # `time_set_vtm` write and `TZMODE_SET_UTC`. Both
             # selectors share the cfunc, so both must be blocked.
-            :gmtime, :utc
+            :gmtime, :utc,
+            # `getlocal` is not a mutator — it returns a fresh Time —
+            # but the fresh Time is pinned to the *analysis machine's*
+            # timezone. Folding it through a `Constant[Time]` carrier
+            # (which only ever holds a UTC literal from `Time.utc`)
+            # would bake a host-dependent wall clock / `utc_offset`
+            # into the inferred type. Blocked so the fold stays
+            # machine-independent; the RBS tier answers `Nominal[Time]`.
+            # `getutc` / `getgm` stay foldable — their result is UTC.
+            :getlocal
           ]
         }
       )