rigortype 0.1.8 → 0.1.10

data/lib/rigor/analysis/check_rules.rb

@@ -355,6 +355,15 @@ module Rigor
           class_name = concrete_class_name(receiver_type)
           return nil if class_name.nil?
 
+          # ADR-26 — a plugin may declare a class "open": one
+          # known to respond beyond its RBS-declared method
+          # surface (e.g. `ActiveRecord::Relation`, which
+          # delegates an unbounded set of user-defined scopes to
+          # its model). Flagging an undefined method on a class
+          # with an open dynamic surface is unsound, so the rule
+          # skips it.
+          return nil if open_receiver?(class_name, scope)
+
           # Slice 7 phase 12 — suppress when the user has
           # declared the method in source (instance `def`,
           # `def self.foo`, or recognised `define_method`).
@@ -424,6 +433,17 @@ module Rigor
           nil
         end
 
+        # ADR-26 — whether `class_name` is declared "open" by a
+        # loaded plugin (manifest `open_receivers:`). An open
+        # class responds beyond its RBS surface, so the
+        # `call.undefined-method` rule must not fire for it.
+        def open_receiver?(class_name, scope)
+          registry = scope.environment&.plugin_registry
+          return false if registry.nil?
+
+          registry.open_receiver?(class_name)
+        end
+
         def definition_available?(receiver_type, class_name, scope)
           if receiver_type.is_a?(Type::Singleton)
             !Rigor::Reflection.singleton_definition(class_name, scope: scope).nil?

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

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "optionparser"
+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"
+
+module Rigor
+  class CLI
+    # Executes `rigor annotate FILE`.
+    #
+    # For every source line the command finds the expression the
+    # line evaluates to — the last statement that ends on the line
+    # (so `1; 2; 3` reports `3`), or, for a line that no statement
+    # closes, the widest expression ending there (so the `if nil`
+    # header reports its condition). It infers that expression's
+    # type and appends a `#=> dump_type: <type>` comment.
+    #
+    # The annotated source is re-parsed with Prism — a sanity gate,
+    # since the appended text is always a comment — and printed to
+    # stdout with IRB-style syntax highlighting via
+    # {PrismColorizer}.
+    class AnnotateCommand
+      USAGE = "Usage: rigor annotate [options] FILE"
+
+      # Appended ` #=> dump_type: <type>` suffix. Matched and
+      # stripped before re-annotating so re-running is idempotent.
+      ANNOTATION_PATTERN = /\s*#=>\s*dump_type:.*\z/
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        file = @argv.shift
+        if file.nil?
+          @err.puts(USAGE)
+          return CLI::EXIT_USAGE
+        end
+        unless File.file?(file)
+          @err.puts("annotate: file not found: #{file}")
+          return 1
+        end
+
+        execute(file, options)
+      end
+
+      private
+
+      def parse_options
+        # Default: colour a tty, unless `NO_COLOR` opts out. An
+        # explicit `--color` / `--no-color` overrides both.
+        options = { config: nil, color: @out.tty? && !no_color_env? }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          opts.on("--[no-]color",
+                  "Force or disable ANSI colour (default: auto-detect a tty; honours NO_COLOR)") do |value|
+            options[:color] = value
+          end
+        end
+        parser.parse!(@argv)
+
+        options
+      end
+
+      # https://no-color.org — colour output is suppressed by
+      # default when `NO_COLOR` is present and not an empty string,
+      # regardless of its value.
+      def no_color_env?
+        value = ENV.fetch("NO_COLOR", nil)
+        !value.nil? && !value.empty?
+      end
+
+      def execute(file, options)
+        configuration = Configuration.load(options.fetch(:config))
+        # 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)
+
+        scope_index = Inference::ScopeIndexer.index(
+          parse_result.value, default_scope: base_scope(configuration)
+        )
+        line_types = LineTypeCollector.new(scope_index).collect(parse_result.value)
+
+        @out.puts(render(annotate(source, line_types), color: options.fetch(:color)))
+        0
+      end
+
+      def base_scope(configuration)
+        Scope.empty(
+          environment: Environment.for_project(
+            libraries: configuration.libraries,
+            signature_paths: configuration.signature_paths
+          )
+        )
+      end
+
+      def parse_errors?(parse_result, file)
+        return false if parse_result.success?
+
+        parse_result.errors.each do |error|
+          @err.puts("#{file}:#{error.location.start_line}: #{error.message}")
+        end
+        true
+      end
+
+      # Appends ` #=> dump_type: <type>` to every line a type was
+      # inferred for, aligning the comment column.
+      def annotate(source, line_types)
+        lines = source.lines
+        column = annotation_column(lines, line_types)
+
+        lines.each_with_index.map do |line, index|
+          type = line_types[index + 1]
+          eol = line.end_with?("\n") ? "\n" : ""
+          code = line.chomp.sub(ANNOTATION_PATTERN, "")
+          next "#{code}#{eol}" if type.nil?
+
+          "#{code.ljust(column)}  #=> dump_type: #{type.describe(:short)}#{eol}"
+        end.join
+      end
+
+      def annotation_column(lines, line_types)
+        widths = lines.each_index.filter_map do |index|
+          next unless line_types.key?(index + 1)
+
+          lines[index].chomp.sub(ANNOTATION_PATTERN, "").length
+        end
+        widths.max || 0
+      end
+
+      def render(annotated, color:)
+        return annotated unless color
+        return annotated unless Prism.parse(annotated).success?
+
+        PrismColorizer.colorize(annotated)
+      end
+    end
+
+    # Walks a parsed program and resolves, per source line, the
+    # type of the expression the line evaluates to. Used only by
+    # {AnnotateCommand}.
+    class LineTypeCollector
+      def initialize(scope_index)
+        @scope_index = scope_index
+      end
+
+      # @param program [Prism::ProgramNode]
+      # @return [Hash{Integer => Rigor::Type}] 1-indexed line => type.
+      def collect(program)
+        by_line = {}
+        each_statement(program) do |statement|
+          type = type_of(statement)
+          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 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?
+
+        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
+      # lines), fall back to the widest expression ending there.
+      def fill_uncovered_lines(program, by_line)
+        widest_per_line(program).each do |line, node|
+          next if by_line.key?(line)
+
+          type = type_of(node)
+          by_line[line] = type unless type.nil?
+        end
+      end
+
+      def widest_per_line(program)
+        widest = {}
+        walk(program) do |node|
+          next if node.is_a?(Prism::ProgramNode) || node.is_a?(Prism::StatementsNode)
+
+          line = node.location.end_line
+          current = widest[line]
+          widest[line] = node if current.nil? || span(node) > span(current)
+        end
+        widest
+      end
+
+      def span(node)
+        node.location.end_offset - node.location.start_offset
+      end
+
+      def walk(node, &block)
+        return if node.nil?
+
+        block.call(node)
+        node.compact_child_nodes.each { |child| walk(child, &block) }
+      end
+
+      def type_of(node)
+        @scope_index[node].type_of(node)
+      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