rigortype 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa449010eccd7d32f8ee61d676a926f9ccde1f68d88a1da211511977e452246
-  data.tar.gz: a0db486f82c3288b2804bce60231734352404c3ceeba11bc6bf0d167c36a633f
+  metadata.gz: 9c5853d88c57eb0ded87f9fbf801e3cfbbc7672be2a16bcc3171bd7e3f33122c
+  data.tar.gz: d3f3b9d936dd4aab4a10c93b7879b34bee26aa1313007619baadb1381b87310c
 SHA512:
-  metadata.gz: 944eb28d30c56593736224523c0668d9d17c0e5f01694d54fbae08664972b2caae97eb246d3d05bdc3e8a2550b4bb81ca6b0d0c476be26b11811b656cbe38e18
-  data.tar.gz: 1dedc56f5e9014618e3cc3f0e689d1447b11d9fa2ce451cd7290c2f5d570848d0dcf4819452398ea6316333fd542590043a7ca70b3e31a61e497c1459431be84
+  metadata.gz: bebba3258c508b893a7ca22e98b17838bcc7267399882956a4ced9c214e87947754f5a15ecf80029cf601eed58c93fc53ffcb50636002df9f75c00d498a0585b
+  data.tar.gz: 4ac6679d930144ffc5a675a9189ed7ce20d500c5ae9d61820b44fcfbf3e02149b615b3b11a44fa48760c17a75b57ec6d6b5ee3e4a80a4b9139514c742c9c612a

data/README.md

@@ -63,7 +63,7 @@ the executable it installs is `rigor`.
 
 Full options — `asdf`, dev containers, CI workflow template — are in the
 [installation guide](https://rigor.typedduck.fail/reference/manual/01-installation/)
-and [CI guide](https://rigor.typedduck.fail/reference/manual/10-ci/).
+and [CI guide](https://rigor.typedduck.fail/reference/manual/11-ci/).
 
 ## Getting started with AI Skills
 

data/lib/rigor/analysis/baseline.rb

@@ -52,6 +52,15 @@ module Rigor
     # CLI or `baseline: <path>` in `.rigor.yml`). The presence
     # of `.rigor-baseline.yml` on disk alone never triggers a
     # load — that's the CLI / Configuration's job to enforce.
+    #
+    # ## Path handling
+    #
+    # Baselines store file paths **relative to the project root**
+    # (the working directory when `rigor` is run). This makes the
+    # generated `.rigor-baseline.yml` portable across machines and
+    # checkout locations. When filtering a live diagnostic stream,
+    # the instance normalises each diagnostic's absolute path to a
+    # relative one before the bucket lookup.
     class Baseline
       # The bucket key is intentionally tuple-shaped so rule-ID
       # rows and message-pattern rows can coexist in a single
@@ -69,12 +78,16 @@ module Rigor
         # path is nil (the caller's "no baseline configured"
         # state). Raises {LoadError} on malformed content;
         # callers translate to a user-facing diagnostic.
-        def load(path)
+        #
+        # `project_root:` is the working directory against which
+        # stored relative paths are resolved during filtering.
+        # Defaults to `Dir.pwd`.
+        def load(path, project_root: Dir.pwd)
           return nil if path.nil?
-          return new([]) unless File.exist?(path)
+          return new([], project_root: project_root) unless File.exist?(path)
 
           raw = YAML.safe_load_file(path, permitted_classes: [Symbol])
-          parse_loaded(raw, path: path)
+          parse_loaded(raw, path: path, project_root: project_root)
         end
 
         # Build a baseline from a current run's diagnostic stream.
@@ -82,10 +95,14 @@ module Rigor
         # message-mode generator passes literal messages through
         # `Regexp.escape` so generated rows never accidentally
         # over-match on punctuation.
-        def from_diagnostics(diagnostics, match_mode: :rule)
+        #
+        # `project_root:` is used to convert absolute diagnostic
+        # paths to relative paths in the generated YAML. Defaults
+        # to `Dir.pwd`.
+        def from_diagnostics(diagnostics, match_mode: :rule, project_root: Dir.pwd)
           raise ArgumentError, "match_mode must be :rule or :message" unless %i[rule message].include?(match_mode)
 
-          grouped = group_for_baseline(diagnostics, match_mode)
+          grouped = group_for_baseline(diagnostics, match_mode, project_root)
           buckets = grouped.map do |key, entries|
             Bucket.new(
               file: key[0],
@@ -94,12 +111,12 @@ module Rigor
               count: entries.size
             )
           end
-          new(buckets)
+          new(buckets, project_root: project_root)
         end
 
         private
 
-        def parse_loaded(raw, path:)
+        def parse_loaded(raw, path:, project_root:)
           raise LoadError, "#{path}: expected a Hash at top level, got #{raw.class}" unless raw.is_a?(Hash)
 
           version = raw["version"]
@@ -110,7 +127,8 @@ module Rigor
           rows = raw["ignored"] || []
           raise LoadError, "#{path}: `ignored:` must be an Array" unless rows.is_a?(Array)
 
-          new(rows.each_with_index.map { |row, idx| parse_row(row, path: path, index: idx) })
+          new(rows.each_with_index.map { |row, idx| parse_row(row, path: path, index: idx) },
+              project_root: project_root)
         end
 
         def parse_row(row, path:, index:)
@@ -141,16 +159,19 @@ module Rigor
         # In message mode, each unique message gets its own bucket;
         # in rule mode, every diagnostic for a (file, rule) pair
         # contributes to a single bucket regardless of message.
-        def group_for_baseline(diagnostics, match_mode)
+        # File paths are normalised to relative before keying.
+        def group_for_baseline(diagnostics, match_mode, project_root)
+          root = Pathname.new(project_root)
           diagnostics.each_with_object({}) do |diag, into|
             next if diag.qualified_rule.nil?
             next if diag.path.nil?
 
+            rel = relative_path(diag.path, root)
             key = case match_mode
                   when :rule
-                    [diag.path, diag.qualified_rule, nil]
+                    [rel, diag.qualified_rule, nil]
                   when :message
-                    [diag.path, diag.qualified_rule, message_pattern_for(diag.message)]
+                    [rel, diag.qualified_rule, message_pattern_for(diag.message)]
                   end
             (into[key] ||= []) << diag
           end
@@ -164,13 +185,20 @@ module Rigor
         def message_pattern_for(message)
           Regexp.new(Regexp.escape(message.to_s))
         end
+
+        def relative_path(path, root_pathname)
+          Pathname.new(path).relative_path_from(root_pathname).to_s
+        rescue ArgumentError
+          path # different drive letter on Windows or non-child path
+        end
       end
 
       class LoadError < StandardError; end
 
       attr_reader :buckets
 
-      def initialize(buckets)
+      def initialize(buckets, project_root: Dir.pwd)
+        @project_root = Pathname.new(project_root)
         @buckets = buckets.freeze
         # For each (file, qualified_rule) pair, two arrays:
         # - rule-ID rows (message_regex == nil)
@@ -264,7 +292,7 @@ module Rigor
       # cleared buckets (`actual == 0`) from the on-disk file.
       def without(buckets_to_drop)
         dropset = buckets_to_drop.to_set
-        self.class.new(buckets.reject { |b| dropset.include?(b) })
+        self.class.new(buckets.reject { |b| dropset.include?(b) }, project_root: @project_root)
       end
 
       # Serialise to a YAML string. The generator path writes
@@ -307,6 +335,14 @@ module Rigor
         [bucket.file, bucket.rule, bucket.message_regex&.source]
       end
 
+      def normalize_path(path)
+        return path if path.nil?
+
+        Pathname.new(path).relative_path_from(@project_root).to_s
+      rescue ArgumentError
+        path # different drive letter on Windows or non-child path
+      end
+
       def group_diagnostics_for_filtering(diagnostics)
         # First pass: bin each diagnostic into the bucket that
         # claims it. Message-pattern rows take precedence over
@@ -322,7 +358,7 @@ module Rigor
                   [bucket.file, bucket.rule,
                    bucket.message_regex&.source]
                 else
-                  [diag.path, diag.qualified_rule, :__none__]
+                  [normalize_path(diag.path), diag.qualified_rule, :__none__]
                 end
           bin = (bins[key] ||= { bucket: bucket, diagnostics: [] })
           bin[:diagnostics] << diag
@@ -331,7 +367,7 @@ module Rigor
       end
 
       def claim_bucket_for(diagnostic)
-        candidates = @by_pair[[diagnostic.path, diagnostic.qualified_rule]]
+        candidates = @by_pair[[normalize_path(diagnostic.path), diagnostic.qualified_rule]]
         return nil if candidates.nil? || candidates.empty?
 
         # Tighter (message-pattern) buckets first, then the

data/lib/rigor/analysis/runner.rb

@@ -7,6 +7,7 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../cache/store"
 require_relative "../plugin"
+require_relative "../plugin/source_rbs_synthesis_reporter"
 require_relative "../rbs_extended/reporter"
 require_relative "../reflection"
 require_relative "../type/combinator"
@@ -97,6 +98,7 @@ module Rigor
         @dependency_source_index = DependencySourceInference::Index::EMPTY
         @rbs_extended_reporter = RbsExtended::Reporter.new
         @boundary_cross_reporter = DependencySourceInference::BoundaryCrossReporter.new
+        @source_rbs_synthesis_reporter = Plugin::SourceRbsSynthesisReporter.new
         # `#run` resets these for each invocation; pre-seed them to
         # empty containers so `build_run_stats` / `pre_file_diagnostics`
         # (private, called only from `#run`) can read them without
@@ -147,6 +149,7 @@ module Rigor
         diagnostics += analyze_files(target_files(expansion))
         diagnostics += rbs_extended_reporter_diagnostics
         diagnostics += boundary_cross_diagnostics
+        diagnostics += source_rbs_synthesis_diagnostics
 
         Result.new(
           diagnostics: apply_severity_profile(diagnostics),
@@ -294,7 +297,7 @@ module Rigor
         if pool_mode?
           dispatch_pool(files)
         else
-          environment = resolve_sequential_environment
+          environment = resolve_sequential_environment(source_files: files)
           result = files.flat_map { |path| analyze_file(path, environment) }
           if @collect_stats
             loader = environment.rbs_loader
@@ -311,8 +314,8 @@ module Rigor
       # runner's diagnostics) when present; otherwise builds a
       # fresh Environment per-call via {#build_runner_environment}
       # — preserving the pre-override behaviour bit-for-bit.
-      def resolve_sequential_environment
-        return build_runner_environment unless @environment_override
+      def resolve_sequential_environment(source_files: [])
+        return build_runner_environment(source_files: source_files) unless @environment_override
 
         @environment_override.attach_reporters!(
           rbs_extended_reporter: @rbs_extended_reporter,
@@ -505,7 +508,14 @@ module Rigor
       # Coordinator-side Environment used by the sequential code
       # path. Pool mode builds one Environment per worker inside
       # the worker Ractor's body instead.
-      def build_runner_environment
+      #
+      # ADR-32 WD4 — `source_files:` is threaded down so that
+      # `Environment.for_project` can invoke each loaded plugin's
+      # `source_rbs_synthesizer` callable per project source file
+      # at env-build time. Defaults to `[]` for callers that don't
+      # have a file list yet (e.g. pre-pass-only build paths); in
+      # that case no synthesised RBS is contributed.
+      def build_runner_environment(source_files: [])
         Environment.for_project(
           libraries: @configuration.libraries,
           signature_paths: @configuration.signature_paths,
@@ -514,13 +524,15 @@ 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,
           bundler_bundle_path: @configuration.bundler_bundle_path,
           bundler_auto_detect: @configuration.bundler_auto_detect,
           bundler_lockfile: @configuration.bundler_lockfile,
           rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
           rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect,
           synthetic_method_index: @synthetic_method_index,
-          project_patched_methods: @project_patched_methods
+          project_patched_methods: @project_patched_methods,
+          source_files: source_files
         )
       end
 
@@ -559,7 +571,7 @@ module Rigor
       # which dedupe on the same keys as a single-session run
       # would. Net result: reporter state is identical to the
       # sequential path.
-      def analyze_files_in_pool(files) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+      def analyze_files_in_pool(files) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         # Pre-warm class-level lazy memos on the MAIN Ractor.
         # `Environment::ClassRegistry.default` is the
         # default kwarg threaded through `Environment.new`
@@ -591,15 +603,22 @@ module Rigor
         cache_root = @cache_store&.root
         blueprints = @plugin_registry.blueprints
         explain = @explain
+        # ADR-32 WD4 — the full project file list travels into
+        # every Ractor worker so each worker's WorkerSession
+        # can invoke loaded plugins' source_rbs_synthesizers at
+        # env-build time. The list is a frozen Array<String>;
+        # cheaply shareable.
+        shareable_source_files = files.map { |path| path.to_s.dup.freeze }.freeze
 
         pool = Array.new(@workers) do
-          Ractor.new(configuration, cache_root, blueprints, explain) do |configuration, cache_root, blueprints, explain|
+          Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files) do |configuration, cache_root, blueprints, explain, shareable_source_files| # rubocop:disable Layout/LineLength
             cache_store = cache_root ? Rigor::Cache::Store.new(root: cache_root) : nil
             session = Rigor::Analysis::WorkerSession.new(
               configuration: configuration,
               cache_store: cache_store,
               plugin_blueprints: blueprints,
-              explain: explain
+              explain: explain,
+              source_files: shareable_source_files
             )
             main = Ractor.main
             main.send([:prepare, session.prepare_diagnostics])
@@ -665,7 +684,8 @@ module Rigor
           plugin_blueprints: @plugin_registry.blueprints,
           explain: @explain,
           synthetic_method_index: @synthetic_method_index,
-          project_patched_methods: @project_patched_methods
+          project_patched_methods: @project_patched_methods,
+          source_files: files
         )
         # Force the full RBS load on the parent so children
         # copy-on-write inherit a warm Environment rather than each
@@ -851,6 +871,15 @@ module Rigor
             rbs_display: entry.rbs_display
           )
         end
+        # ADR-32 WD6 — merge per-worker synthesizer failures
+        # back into the coordinator's reporter. Fetched with a
+        # default empty array so older drains (pre-slice-2)
+        # remain compatible.
+        Array(drained[:source_rbs_synthesis]).each do |entry|
+          @source_rbs_synthesis_reporter.record(
+            plugin_id: entry.plugin_id, path: entry.path, message: entry.message
+          )
+        end
       end
 
       # Loads project-configured plugins through {Rigor::Plugin::Loader}
@@ -1160,6 +1189,35 @@ module Rigor
       # per-call-site — the diagnostic anchors at `.rigor.yml`
       # like the other `dependency-source.*` diagnostics that
       # report on opt-in configuration.
+      # ADR-32 WD6 — drains the per-run
+      # {Plugin::SourceRbsSynthesisReporter} into
+      # `source-rbs-synthesis-failed` `:info` diagnostics. Each
+      # entry names the plugin that owns the synthesizer, the
+      # source file the rbs-inline parser couldn't process, and
+      # the upstream error message. The synthesizer-emitting
+      # plugin (currently only `rigor-rbs-inline`) treats a
+      # parse failure as a no-contribution event so analysis
+      # continues; this stream surfaces the failure so the user
+      # can see which files contributed nothing and why.
+      #
+      # Severity profile re-stamps the rule per project taste.
+      def source_rbs_synthesis_diagnostics
+        return [] if @source_rbs_synthesis_reporter.empty?
+
+        @source_rbs_synthesis_reporter.entries.map do |entry|
+          Diagnostic.new(
+            path: entry.path, line: 1, column: 1,
+            message: "plugin `#{entry.plugin_id}` failed to synthesise RBS from this file: " \
+                     "#{entry.message}. The file's analysis falls back to no inline-RBS " \
+                     "contribution. Fix the inline-RBS comment grammar or remove the " \
+                     "annotation to silence this diagnostic.",
+            severity: :info,
+            rule: "source-rbs-synthesis-failed",
+            source_family: :builtin
+          )
+        end
+      end
+
       def boundary_cross_diagnostics
         return [] if @boundary_cross_reporter.empty?
 

data/lib/rigor/analysis/worker_session.rb

@@ -93,15 +93,20 @@ module Rigor
       #   emits one `:info` `fallback` diagnostic per
       #   directly-unrecognised node, mirroring
       #   {Rigor::Analysis::Runner#explain_diagnostics}.
-      def initialize(configuration:, cache_store: nil, # rubocop:disable Metrics/MethodLength
+      def initialize(configuration:, cache_store: nil, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
                      plugin_blueprints: [], explain: false, buffer: nil,
-                     synthetic_method_index: nil, project_patched_methods: nil)
+                     synthetic_method_index: nil, project_patched_methods: nil,
+                     source_files: [])
         @configuration = configuration
         @cache_store = cache_store
         @explain = explain
         @buffer = buffer
         @synthetic_method_index = synthetic_method_index
         @project_patched_methods = project_patched_methods
+        # ADR-32 WD4 — full project file list (frozen
+        # Array<String>) for env-build-time invocation of any
+        # loaded plugin's `source_rbs_synthesizer` callable.
+        @source_files = source_files
 
         # NOTE: `Inference::MethodDispatcher::FileFolding.fold_platform_specific_paths`
         # is process-global state. Writing it from a non-main
@@ -112,6 +117,7 @@ module Rigor
         # pool. The substrate stays Ractor-safe by construction.
         @rbs_extended_reporter = RbsExtended::Reporter.new
         @boundary_cross_reporter = DependencySourceInference::BoundaryCrossReporter.new
+        @source_rbs_synthesis_reporter = Plugin::SourceRbsSynthesisReporter.new
         @dependency_source_index = DependencySourceInference::Builder.build(configuration.dependencies)
 
         @services = Plugin::Services.new(
@@ -132,13 +138,15 @@ 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,
           bundler_bundle_path: configuration.bundler_bundle_path,
           bundler_auto_detect: configuration.bundler_auto_detect,
           bundler_lockfile: configuration.bundler_lockfile,
           rbs_collection_lockfile: configuration.rbs_collection_lockfile,
           rbs_collection_auto_detect: configuration.rbs_collection_auto_detect,
           synthetic_method_index: @synthetic_method_index,
-          project_patched_methods: @project_patched_methods
+          project_patched_methods: @project_patched_methods,
+          source_files: @source_files
         )
         @prepare_diagnostics = run_plugin_prepare.freeze
       end
@@ -180,7 +188,8 @@ module Rigor
             unresolved_payloads: @rbs_extended_reporter.unresolved_payloads,
             lossy_projections: @rbs_extended_reporter.lossy_projections
           },
-          boundary_cross: @boundary_cross_reporter.entries
+          boundary_cross: @boundary_cross_reporter.entries,
+          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries
         }
       end
 

data/lib/rigor/cache/rbs_descriptor.rb

@@ -19,7 +19,7 @@ module Rigor
         Descriptor.new(
           gems: [rbs_gem_entry],
           files: file_entries(loader),
-          configs: [libraries_entry(loader)]
+          configs: [libraries_entry(loader), virtual_rbs_entry(loader)].compact
         )
       end
 
@@ -51,7 +51,26 @@ module Rigor
         )
       end
 
-      private_class_method :rbs_gem_entry, :file_entries, :libraries_entry
+      # ADR-32 WD5 — encode the loader's virtual_rbs set into a
+      # `ConfigEntry` so the env cache invalidates when a
+      # plugin-contributed synthesised RBS string changes (or
+      # appears for the first time). Returns nil when the
+      # loader has no virtual_rbs entries, so callers without
+      # any synthesizer-emitting plugin pay zero descriptor
+      # cost.
+      def self.virtual_rbs_entry(loader)
+        return nil unless loader.respond_to?(:virtual_rbs)
+        return nil if loader.virtual_rbs.nil? || loader.virtual_rbs.empty?
+
+        sorted_pairs = loader.virtual_rbs.sort_by { |name, _content| name }
+        joined = sorted_pairs.map { |name, content| "#{name}\0#{content}" }.join("\n\0\n")
+        Descriptor::ConfigEntry.new(
+          key: "rbs.virtual_rbs",
+          value_hash: Digest::SHA256.hexdigest(joined)
+        )
+      end
+
+      private_class_method :rbs_gem_entry, :file_entries, :libraries_entry, :virtual_rbs_entry
     end
   end
 end

data/lib/rigor/cache/rbs_environment.rb

@@ -42,7 +42,8 @@ module Rigor
       def self.compute(loader)
         Rigor::Environment::RbsLoader.build_env_for(
           libraries: loader.libraries,
-          signature_paths: loader.signature_paths
+          signature_paths: loader.signature_paths,
+          virtual_rbs: loader.respond_to?(:virtual_rbs) ? loader.virtual_rbs : []
         )
       end
 

data/lib/rigor/cli/annotate_command.rb

@@ -6,6 +6,7 @@ require "prism"
 require_relative "../configuration"
 require_relative "../environment"
 require_relative "../scope"
+require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
 require_relative "prism_colorizer"
 
@@ -83,7 +84,15 @@ module Rigor
 
       def execute(file, options)
         configuration = Configuration.load(options.fetch(:config))
-        source = File.read(file)
+        # Force UTF-8 (with BOM tolerance) regardless of
+        # `Encoding.default_external`. Under a minimal locale
+        # the default is US-ASCII; reading multi-byte source
+        # under that tag makes the post-parse `String#sub` /
+        # `String#lines` calls in `#annotate` raise
+        # `invalid byte sequence in US-ASCII`. Ruby source is
+        # UTF-8 by convention (the parser's own assumption
+        # absent a magic comment).
+        source = File.read(file, mode: "r:bom|utf-8")
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         return 1 if parse_errors?(parse_result, file)
 
@@ -164,20 +173,33 @@ module Rigor
           by_line[statement.location.end_line] = type unless type.nil?
         end
         fill_uncovered_lines(program, by_line)
+        override_def_header_lines(program, by_line)
         by_line
       end
 
       private
 
       # Yields each statement node (a child of any `StatementsNode`
-      # anywhere in the tree) in source order, so a later statement
-      # ending on a line overwrites an earlier one — `1; 2; 3`
-      # resolves to `3`.
-      def each_statement(node, &)
+      # anywhere in the tree) in post-order: nested statements are
+      # yielded before the enclosing statement that contains them.
+      # `by_line[end_line] = type` overwrites earlier entries, so
+      # post-order means the *outermost* statement closing a line
+      # wins — for `b = if cond then :then else :else end` the
+      # line resolves to the assignment's type (the if-expression's
+      # union), not the else-branch's inner `:else`. Direct siblings
+      # (`1; 2; 3`) are still yielded in source order so the last
+      # sibling wins.
+      def each_statement(node, &block)
         return if node.nil?
 
-        node.body.each(&) if node.is_a?(Prism::StatementsNode)
-        node.compact_child_nodes.each { |child| each_statement(child, &) }
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each do |stmt|
+            each_statement(stmt, &block)
+            block.call(stmt)
+          end
+        else
+          node.compact_child_nodes.each { |child| each_statement(child, &block) }
+        end
       end
 
       # For a line no statement closes (the `if` / block header
@@ -219,6 +241,34 @@ module Rigor
       rescue StandardError
         nil
       end
+
+      # For every `def`, replace the annotation on the header line
+      # (where the `def` keyword sits) with the method's inferred
+      # return type. The default annotation there comes from the
+      # parameter list (`name` typing as `Dynamic[top]`), which is
+      # noise; the return type is what readers actually want next
+      # to the method signature. When the return type cannot be
+      # inferred (empty body, scope-lookup miss, or any error
+      # under `DefReturnTyper.call`), the entry is deleted so no
+      # annotation is shown on that line.
+      def override_def_header_lines(program, by_line)
+        each_def_node(program) do |def_node|
+          line = def_node.location.start_line
+          return_type = Inference::DefReturnTyper.call(def_node, @scope_index)
+          if return_type.nil?
+            by_line.delete(line)
+          else
+            by_line[line] = return_type
+          end
+        end
+      end
+
+      def each_def_node(node, &block)
+        return if node.nil?
+
+        block.call(node) if node.is_a?(Prism::DefNode)
+        node.compact_child_nodes.each { |child| each_def_node(child, &block) }
+      end
     end
   end
 end

data/lib/rigor/cli/baseline_command.rb

@@ -84,7 +84,8 @@ module Rigor
         configuration = Configuration.load(options.fetch(:config))
         diagnostics = collect_diagnostics(configuration, options)
 
-        baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode))
+        baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode),
+                                                                    project_root: Dir.pwd)
         File.write(path, baseline.to_yaml)
 
         @err.puts(
@@ -149,7 +150,7 @@ module Rigor
         defaults = Configuration::DEFAULTS.merge(
           "paths" => configuration.paths,
           "exclude" => configuration.exclude_patterns,
-          "plugins" => configuration.plugins.map(&:to_h),
+          "plugins" => configuration.plugins,
           "disable" => configuration.disabled_rules,
           "libraries" => configuration.libraries,
           "signature_paths" => configuration.signature_paths,
@@ -372,7 +373,7 @@ module Rigor
           @err.puts("rigor: baseline file not found: #{path}")
           return :error
         end
-        Analysis::Baseline.load(path)
+        Analysis::Baseline.load(path, project_root: Dir.pwd)
       rescue Analysis::Baseline::LoadError => e
         @err.puts("rigor: baseline load failed: #{e.message}")
         :error