rigortype 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa449010eccd7d32f8ee61d676a926f9ccde1f68d88a1da211511977e452246
-  data.tar.gz: a0db486f82c3288b2804bce60231734352404c3ceeba11bc6bf0d167c36a633f
+  metadata.gz: 3425a6183f3c9312517a9a82de77b561907c0afd99f8f77844d08741a766fae8
+  data.tar.gz: cef2e0e925fb844e4112552626966319c942ff0f31ff6d2af05b04ec8c2ee93f
 SHA512:
-  metadata.gz: 944eb28d30c56593736224523c0668d9d17c0e5f01694d54fbae08664972b2caae97eb246d3d05bdc3e8a2550b4bb81ca6b0d0c476be26b11811b656cbe38e18
-  data.tar.gz: 1dedc56f5e9014618e3cc3f0e689d1447b11d9fa2ce451cd7290c2f5d570848d0dcf4819452398ea6316333fd542590043a7ca70b3e31a61e497c1459431be84
+  metadata.gz: 749cd171f08f03311d70da91e742b07980974876889d152827ae8e3aa4518d2c2f933475efa889e3c63a7f715eddb96112584445967c3e15fe7c58c38d0ed3cd
+  data.tar.gz: bb5f032e6663cb137b774bfd18d39ad1498b0913d552a92b86c0256fd8a2fb76c1426d9914f01caf3f78359c96079d8dfc7c84f09e2fb473681cf0889ee46e09

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/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/coverage_command.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "optionparser"
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../inference/precision_scanner"
+require_relative "../scope"
+require_relative "coverage_report"
+require_relative "coverage_renderer"
+
+module Rigor
+  class CLI
+    # Executes the `rigor coverage` command.
+    #
+    # Walks every Prism node in one or more files, infers its type via
+    # `Rigor::Scope#type_of`, and classifies the result into precision tiers
+    # (constant / nominal / shaped / refined / bot / dynamic_specific /
+    # dynamic_top / top).  Reports aggregate and per-file statistics so
+    # maintainers can track type-precision trends and SKILL pipelines can
+    # measure the impact of adding new constant-fold or shape-dispatch rules.
+    #
+    # Exit codes:
+    #   0  — scan complete, precision ratio ≥ threshold (or no threshold given)
+    #   1  — precision ratio < threshold, or parse errors encountered
+    #   64 — usage error
+    class CoverageCommand
+      USAGE = "Usage: rigor coverage [options] PATH..."
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        paths = collect_paths(@argv)
+        return CLI::EXIT_USAGE if paths.nil?
+        return usage_error if paths.empty?
+
+        report = scan_paths(paths, options)
+        CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_exit(report, options)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", threshold: nil, config: nil }
+
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on(
+            "--threshold=RATIO", Float,
+            "Exit 1 when precision ratio is below RATIO (0.0–1.0)"
+          ) { |v| options[:threshold] = v }
+        end.parse!(@argv)
+
+        options
+      end
+
+      def collect_paths(args)
+        paths = []
+        args.each do |arg|
+          if File.directory?(arg)
+            paths.concat(Dir.glob(File.join(arg, "**/*.rb")))
+          elsif File.file?(arg)
+            paths << arg
+          else
+            @err.puts("coverage: not a file or directory: #{arg}")
+            return nil
+          end
+        end
+        paths.uniq
+      end
+
+      def usage_error
+        @err.puts("coverage: at least one path is required")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def scan_paths(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        scope = Scope.empty(environment: project_environment(configuration))
+        scanner = Inference::PrecisionScanner.new(scope: scope)
+        accumulator = CoverageAccumulator.new
+
+        paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
+        accumulator.to_report(paths, options)
+      end
+
+      def project_environment(configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
+      end
+
+      def scan_one(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(path, scanner.scan(parse_result.value))
+      end
+
+      def determine_exit(report, options)
+        return 1 unless report.parse_errors.empty?
+
+        threshold = options[:threshold]
+        return 0 if threshold.nil?
+
+        report.precision_ratio < threshold ? 1 : 0
+      end
+    end
+  end
+end