rigortype 0.4.2 → 0.4.3

data/lib/rigor/lens/plugins.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../version"
+
+module Rigor
+  module Lens
+    # `context.plugins` (docs/internal-spec/lens.md § Context): the plugins a run loaded, by manifest id.
+    module Plugins
+      BUNDLED_PLUGINS = File.expand_path("../../../plugins", __dir__).freeze
+
+      module_function
+
+      # `[{id, version}]` by manifest id (the id slot provenance uses). The version is Rigor's for a plugin bundled
+      # with it, else the version of the gem whose files define the plugin class, else null. A plugin id is not a gem
+      # name: the bundled `rbs-inline` plugin shares its id with the upstream gem.
+      def loaded(environment)
+        plugins = environment&.plugin_registry&.plugins || []
+        rows = plugins.map { |plugin| { "id" => plugin.manifest.id.to_s, "version" => version(plugin) } }
+        rows.uniq.sort_by { |plugin| plugin["id"] }
+      rescue StandardError
+        []
+      end
+
+      def version(plugin)
+        file = Object.const_source_location(plugin.class.name)&.first
+        return nil if file.nil?
+
+        absolute = File.expand_path(file)
+        return Rigor::VERSION if absolute.start_with?("#{BUNDLED_PLUGINS}/")
+
+        spec = Gem.loaded_specs.each_value.find do |gem|
+          absolute.start_with?("#{gem.full_gem_path}/") # rigor:disable undefined-method
+        end
+        spec&.version&.to_s
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/lens/run.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "file_reader"
+require_relative "contract_reader"
+require_relative "members"
+require_relative "plugins"
+require_relative "slot"
+require_relative "../analysis/incremental_session"
+require_relative "../cache/incremental_snapshot"
+require_relative "../cache/store"
+require_relative "../sig_gen/alias_index"
+require_relative "../sig_gen/type_elaborator"
+
+module Rigor
+  module Lens
+    # The check-equivalent computation behind `rigor lens` (docs/internal-spec/lens.md § Computation). The session
+    # is the `--incremental` one rooted at the configuration's `paths:`, so it shares the snapshot with
+    # `rigor check --incremental`; the targets are forced into the run and read inside it, on the seeded index.
+    class Run
+      # One target's answer: `status` is `ok` or a failure reason; the rest is set only for `ok`.
+      Target = Data.define(:argument, :path, :absolute, :status, :reason, :reader, :diagnostics, :inputs)
+      Outcome = Data.define(:targets, :member_rows, :plugins, :warm)
+
+      # @param root — the project root (absolute); every path in the answer is relative to it
+      def initialize(configuration:, root:, arguments:, workers:)
+        @configuration = configuration
+        @root = root
+        @arguments = arguments
+        @argument_paths = arguments.to_set { |argument| File.expand_path(argument) }
+        @workers = workers
+        reset_captures
+        @capture_errors = {}
+        @plugins = []
+      end
+
+      def call
+        session = build_session
+        project = session.project_files.to_h { |path| [File.expand_path(path), path] }
+        resolved = mark_duplicates(@arguments.map { |argument| resolve(argument, project) })
+        forced = resolved.filter_map { |entry| entry[:session_path] }
+        session.force_targets = forced.uniq
+        diagnostics, warm = analyse(session, forced.uniq)
+        targets = resolved.map { |entry| target(entry, diagnostics, session) }
+        Outcome.new(targets: targets, member_rows: members(targets, session), plugins: @plugins, warm: warm)
+      end
+
+      private
+
+      def build_session
+        cache_root = @configuration.cache_path
+        Analysis::IncrementalSession.new(
+          configuration: @configuration,
+          cache_store: Cache::Store.new(root: cache_root, max_bytes: @configuration.cache_max_bytes),
+          workers: @workers, on_file_indexed: method(:capture)
+        )
+      end
+
+      # A warm run is a recheck that forced the targets. A cold one is a baseline: a sequential baseline indexes
+      # every target in this process, a pooled one in workers where the callback never runs. The session also
+      # falls back to a baseline after a recheck whose seeds it no longer trusts, and the captures that recheck
+      # made are stale. So after a pooled baseline the captures are dropped and one forced recheck, on the
+      # baseline's fresh state, reads the targets again.
+      def analyse(session, forced)
+        fingerprint = Cache::IncrementalSnapshot.fingerprint(configuration: @configuration,
+                                                             roots: @configuration.paths)
+        snapshot = Cache::IncrementalSnapshot.new(root: @configuration.cache_path)
+        diagnostics, warm = session.run_incremental(snapshot: snapshot, fingerprint: fingerprint)
+        missing = forced.reject { |path| @captured.key?(File.expand_path(path)) }
+        if (!warm && @workers.positive?) || !missing.empty?
+          reset_captures
+          diagnostics = session.recheck.diagnostics
+        end
+        [diagnostics, warm]
+      end
+
+      def reset_captures
+        @captured = {}
+        @contracts = {}
+        @site_paths = {}
+      end
+
+      # A file requested again, in any spelling, is answered once: the later entries read `duplicate`, naming the
+      # argument that carries the answer, so every site key stays unique in the document.
+      def mark_duplicates(entries)
+        first = {}
+        entries.map do |entry|
+          next entry unless entry[:status] == "ok"
+
+          seen = first[entry[:absolute]]
+          first[entry[:absolute]] ||= entry[:argument]
+          next entry unless seen
+
+          entry.merge(status: "duplicate", reason: "the same file as #{seen}", session_path: nil)
+        end
+      end
+
+      def resolve(argument, project)
+        absolute = File.expand_path(argument)
+        entry = { argument: argument, absolute: absolute, path: relative(absolute) }
+        return entry.merge(status: "not_found", reason: "no such file") unless File.file?(absolute)
+        return entry.merge(status: "not_ruby", reason: "not a Ruby source file") unless absolute.end_with?(".rb")
+
+        session_path = project[absolute]
+        return entry.merge(status: "outside_project", reason: "not under the configured paths:") unless session_path
+
+        entry.merge(status: "ok", session_path: session_path)
+      end
+
+      # The runner's index callback. An error here never reaches the run: it is recorded, and the target reads
+      # `failed` with the reason.
+      def capture(path, parse_result, scope, index)
+        absolute = File.expand_path(path)
+        return unless @argument_paths.include?(absolute)
+
+        @plugins = Plugins.loaded(scope.environment) if @plugins.empty?
+        read_target(absolute, parse_result, scope, index)
+        @capture_errors.delete(absolute)
+      rescue StandardError => e
+        @captured.delete(absolute)
+        @capture_errors[absolute] = "#{e.class}: #{e.message}"
+      end
+
+      def read_target(absolute, parse_result, scope, index)
+        reader = FileReader.new(path: relative(absolute), parse_result: parse_result, index: index,
+                                spell: speller(scope.environment)).read
+        reader.sites.each do |site|
+          @site_paths[site.data["key"]] = absolute
+          site.data["members"].each { |name| read_contract(site.data["owner"], site.data["scope"], name, scope) }
+        end
+        @captured[absolute] = reader
+      end
+
+      def read_contract(owner, member_scope, name, scope)
+        key = [owner, member_scope, name]
+        return if @contracts.key?(key)
+
+        @contracts[key] = contract_reader(scope.environment).read(owner, member_scope.to_sym, name, scope)
+      end
+
+      def target(entry, diagnostics, session)
+        base = { argument: entry[:argument], path: entry[:path], absolute: entry[:absolute], status: entry[:status],
+                 reason: entry[:reason], reader: nil, diagnostics: nil, inputs: nil }
+        return Target.new(**base) unless entry[:status] == "ok"
+
+        reader = @captured[entry[:absolute]]
+        own = diagnostics.select { |diagnostic| File.expand_path(diagnostic.path.to_s) == entry[:absolute] }
+        if reader
+          return Target.new(**base, reader: reader, diagnostics: own,
+                                    inputs: inputs(session, entry[:session_path]))
+        end
+
+        Target.new(**base, **uncaptured(entry[:absolute], own))
+      end
+
+      # A forced target the run did not read: one that does not parse stops before indexing; otherwise reading it
+      # failed, or the run never indexed it.
+      def uncaptured(absolute, own)
+        if parse_errors?(absolute)
+          { status: "parse_error", reason: "the file does not parse", diagnostics: own }
+        else
+          { status: "failed", reason: @capture_errors.fetch(absolute, "the file was not analysed") }
+        end
+      rescue StandardError => e
+        # The parse itself failed (an unsupported `target_ruby`, say): the run's own parse did too.
+        { status: "failed", reason: "#{e.class}: #{e.message}" }
+      end
+
+      def parse_errors?(absolute)
+        Prism.parse_file(absolute, version: @configuration.target_ruby).errors.any?
+      end
+
+      def inputs(session, session_path)
+        rows = session.dependency_sources(session_path).filter_map do |source|
+          absolute = File.expand_path(source)
+          next if absolute == File.expand_path(session_path) || !File.file?(absolute)
+
+          { "path" => relative(absolute), "digest" => Lens.digest(File.binread(absolute)) }
+        end
+        rows.sort_by { |input| input["path"] }
+      end
+
+      def members(targets, session)
+        # A file requested twice, in any spelling, contributes its declarations once.
+        readers = targets.filter_map { |target| target.reader && [target.absolute, target.reader] }.to_h
+        sites = readers.values.flat_map(&:sites)
+        omissions = readers.values.flat_map(&:omissions)
+        requested = readers.keys.to_set
+        Members.new(sites: sites, omissions: omissions, contracts: @contracts,
+                    elsewhere: elsewhere(session, requested), site_paths: @site_paths).build
+      end
+
+      # Other project files that define a member, from the per-file discovery bundles the session keeps. The bundle
+      # paths are resolved once; each member then costs one lookup per bundle.
+      def elsewhere(session, requested)
+        bundles = session.seed_bundles.filter_map do |path, bundle|
+          absolute = File.expand_path(path)
+          [relative(absolute), bundle] unless requested.include?(absolute)
+        end
+        lambda do |owner, scope, name|
+          entries = bundles.filter_map do |path, bundle|
+            line = defined_line(bundle, owner, scope, name)
+            line == false ? nil : { "path" => path, "line" => line }
+          end
+          entries.sort_by { |entry| entry["path"] }
+        end
+      end
+
+      # The line a bundle records for the member, nil when it defines the member without a recorded line (an
+      # `attr_*`), or false when it does not define it.
+      # A top-level `def` is recorded under discovery's own key, apart from `class Object`; both count for
+      # `Object#name`.
+      def defined_line(bundle, owner, scope, name)
+        owners = if owner == "Object" && scope == "instance"
+                   [owner,
+                    Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY]
+                 else
+                   [owner]
+                 end
+        owners.each do |key|
+          line = defined_line_for(bundle, key, scope, name)
+          return line unless line == false
+        end
+        false
+      end
+
+      def defined_line_for(bundle, owner, scope, name)
+        table = scope == "singleton" ? bundle[:singleton_def_sources] : bundle[:def_sources]
+        source = table&.dig(owner, name.to_sym)
+        return Integer(source.to_s.split(":").last) if source
+
+        kinds = bundle[:methods]&.dig(owner, name.to_sym)
+        return false if kinds.nil?
+        return nil if kinds == :both || kinds.to_s == scope
+
+        false
+      end
+
+      def speller(environment)
+        @alias_index ||= SigGen::AliasIndex.build(environment: environment, signature_paths: signature_roots,
+                                                  excluded_paths: plugin_signature_paths(environment))
+        lambda do |type, owner|
+          @alias_index.fold(SigGen::TypeElaborator.elaborate(type, environment: environment).erase_to_rbs, owner)
+        end
+      end
+
+      def contract_reader(environment)
+        @contract_reader ||= ContractReader.new(
+          Provenance.new(root: @root, signature_roots: signature_roots.map { |path| File.expand_path(path.to_s) },
+                         plugin_roots: plugin_roots(environment))
+        )
+      end
+
+      # `{absolute signature directory => plugin id}` for every loaded plugin that ships signatures.
+      def plugin_roots(environment)
+        plugins = environment&.plugin_registry&.plugins || []
+        plugins.each_with_object({}) do |plugin, roots|
+          Array(plugin.signature_paths).each { |path| roots[File.expand_path(path.to_s)] = plugin.manifest.id }
+        end
+      rescue StandardError
+        {}
+      end
+
+      def signature_roots
+        @signature_roots ||= Environment.project_signature_roots(@configuration.signature_paths)
+      end
+
+      def plugin_signature_paths(environment)
+        environment&.plugin_registry&.signature_paths || []
+      rescue StandardError
+        []
+      end
+
+      def relative(absolute)
+        Pathname(absolute).relative_path_from(Pathname(@root)).to_s
+      end
+    end
+  end
+end

data/lib/rigor/lens/slot.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Lens
+    # Tagged type slots and RBS-buffer provenance (docs/internal-spec/lens.md § Slots).
+    module Slot
+      module_function
+
+      def typed(type, provenance, path: nil, from_site: nil)
+        { "state" => "typed", "type" => type, "provenance" => provenance, "path" => path, "from_site" => from_site }
+      end
+
+      def dynamic(provenance, cause, path: nil, from_site: nil)
+        { "state" => "dynamic", "type" => "untyped", "provenance" => provenance, "path" => path,
+          "from_site" => from_site, "cause" => cause&.to_s }
+      end
+
+      def unavailable(reason)
+        { "state" => "unavailable", "reason" => reason }
+      end
+
+      def unavailable?(slot)
+        slot.is_a?(Hash) && slot["state"] == "unavailable"
+      end
+
+      # A slot for an RBS type string read from a contract. `untyped` is a dynamic slot whose cause is the
+      # authored contract.
+      def from_rbs(type, provenance, path)
+        return dynamic(provenance, :explicit_untyped, path: path) if type == "untyped"
+
+        typed(type, provenance, path: path)
+      end
+
+      # The RBS type a slot puts in an overload's `rbs` string: an unavailable slot reads `untyped`.
+      def rbs_spelling(slot)
+        slot["state"] == "typed" ? slot["type"] : "untyped"
+      end
+    end
+
+    # Maps an RBS member's buffer name to a provenance (§ Slots).
+    class Provenance
+      CACHED_BUFFER = "<cached>"
+
+      # @param root — the project root (absolute)
+      # @param signature_roots — the project signature roots (absolute)
+      # @param plugin_roots — `{absolute signature directory => plugin id}` of the loaded plugins
+      def initialize(root:, signature_roots:, plugin_roots:)
+        @root = root
+        @signature_roots = signature_roots
+        @plugin_roots = plugin_roots
+      end
+
+      # [provenance, path] for a buffer name, or nil when the buffer cannot be classified.
+      def classify(buffer_name)
+        name = buffer_name.to_s
+        return ["inline", nil] if name.start_with?("virtual:rbs-inline:")
+        return ["plugin:#{name.split(':', 3)[1]}", nil] if name.start_with?("virtual:")
+        return nil if name.empty? || name == CACHED_BUFFER
+
+        absolute = File.expand_path(name, @root)
+        plugin = @plugin_roots.find { |root, _| under?(absolute, [root]) }
+        return ["plugin:#{plugin.last}", nil] if plugin
+        return ["sig", relative(absolute)] if under?(absolute, @signature_roots)
+
+        ["library", nil]
+      end
+
+      def relative(absolute)
+        Pathname(absolute).relative_path_from(Pathname(@root)).to_s
+      end
+
+      private
+
+      def under?(absolute, roots)
+        roots.any? { |root| absolute == root || absolute.start_with?("#{root}/") }
+      end
+    end
+  end
+end

data/lib/rigor/lens.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "hashing/xxh3"
+
+module Rigor
+  # `rigor lens`: a declaration map of the requested files with type provenance, computed as `rigor check` computes
+  # them (ADR-113; the output contract is docs/internal-spec/lens.md).
+  module Lens
+    SCHEMA = "lens/v0"
+    # Bumped on every breaking change to the `lens/v0` document (docs/internal-spec/lens.md § Status).
+    REVISION = 1
+    CAPABILITIES = %w[class module method attribute body_return diagnostics inputs].freeze
+
+    module_function
+
+    # A Prism location as the document's span object: 1-based lines, 0-based byte columns and offsets.
+    def span(location)
+      { "start_line" => location.start_line, "start_column" => location.start_column,
+        "end_line" => location.end_line, "end_column" => location.end_column,
+        "start_offset" => location.start_offset, "end_offset" => location.end_offset }
+    end
+
+    # The span from the first to the last of a site's contract comments, or nil when it has none.
+    def contract_span(comments)
+      return nil if comments.empty?
+
+      first = comments.first.location
+      last = comments.last.location
+      { "start_line" => first.start_line, "start_column" => first.start_column, "end_line" => last.end_line,
+        "end_column" => last.end_column, "start_offset" => first.start_offset, "end_offset" => last.end_offset }
+    end
+
+    def digest(bytes)
+      "xxh3-64:#{Hashing::XXH3.file_hash(bytes)}"
+    end
+  end
+end
+
+require_relative "lens/run"
+require_relative "lens/document"

data/lib/rigor/project_environment.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "environment"
+require_relative "inference/project_patched_scanner"
 require_relative "plugin"
 require_relative "plugin/loader"
 require_relative "plugin/services"
@@ -55,9 +56,12 @@ module Rigor
     #   `source_rbs_synthesizer` runs over them at env-build time; an empty list contributes no synthesized RBS.
     # @param feature_sources — path => source text the required-feature scan reads in place of that file (an
     #   editor buffer bound with `--tmp-file` / `--instead-of`).
-    def build(configuration:, source_files:, feature_sources: {})
+    # @param project_patched_methods — the `pre_eval:` registry (see {.project_patched_methods}); nil keeps
+    #   the unpatched universe.
+    def build(configuration:, source_files:, feature_sources: {}, project_patched_methods: nil)
       features = required_features(configuration, source_files, sources: feature_sources)
       Environment.for_project(
+        project_patched_methods: project_patched_methods,
         libraries: configuration.libraries,
         signature_paths: configuration.signature_paths,
         plugin_registry: load_plugin_registry(configuration),
@@ -69,6 +73,21 @@ module Rigor
       bare(configuration, features)
     end
 
+    # The patched-method registry `rigor check` types against for the project's `pre_eval:` files. It depends
+    # on those files alone, so it is built by the same {Inference::ProjectPatchedScanner} the Runner's project
+    # pre-pass calls, over the same resolved `configuration.pre_eval` entries (glob-expanded at config load,
+    # missing files skipped), without the pre-pass's plugin load / `#prepare` / dependency-source work. An
+    # editor `buffer` is honoured, so a `--tmp-file` edit of a pre_eval file is read in flight. Nil when the
+    # project lists no `pre_eval:` entry, so a project without one stays byte-identical. Fail-soft.
+    def project_patched_methods(configuration, buffer: nil)
+      return nil if configuration.pre_eval.empty?
+
+      existing = configuration.pre_eval.select { |path| File.file?(path) }
+      Inference::ProjectPatchedScanner.scan(existing, buffer: buffer).registry
+    rescue StandardError
+      nil
+    end
+
     # Issue #1700 — the {Environment::RequiredFeatures} the environment gates on: the configured paths plus
     # `extra_files` (the file a probe inspects, which may lie outside them), the same set `rigor check` scans
     # whichever files it is given, so a position types as `rigor check` types it.

data/lib/rigor/protection/mutation_cache.rb

@@ -84,7 +84,8 @@ module Rigor
 
       # Human-readable reasons the caller prints. Each names something the operator can act on.
       NO_SNAPSHOT = "no reusable `rigor check --incremental` snapshot"
-      OPAQUE_PLUGIN = "a plugin contributes types with no incremental fingerprint surface"
+      OPAQUE_PLUGIN = "a plugin is opaque to the incremental fingerprint " \
+                      "(no fingerprint surface, or a value it cannot digest)"
       UNDIGESTIBLE = "the project-scan tables could not be digested"
       UNIDENTIFIED_ENGINE = "the engine's own source tree could not be digested"
 

data/lib/rigor/scope.rb

@@ -251,11 +251,11 @@ module Rigor
     # class in a project that publishes nothing) allocates none.
     EMPTY_PUBLISHED_CONSTANT_IVARS = Set.new.freeze
     # The index `||=` sites of a repeating block body whose slot an earlier run of the body may have filled,
-    # keyed by node identity and laid by a block-return pass at the body's entry
-    # ({#with_repeated_or_writes}; `Inference::RepeatedOrWrites` decides which). The memoizing `||=` reading
-    # (`StatementEvaluator#index_compound_write_value`) is withheld at such a site. The mark belongs to the
-    # site, so no rebind or narrowing of a variable drops it, and a join keeps a site either arm holds: the
-    # mark only ever withholds that reading, whose answer is the narrower one.
+    # keyed by node identity and laid at the body's entry by a block-return pass or by `StatementEvaluator`'s
+    # statement and write-back passes ({#with_repeated_or_writes}; `Inference::RepeatedOrWrites` decides which).
+    # The memoizing `||=` reading (`StatementEvaluator#index_compound_write_value`) is withheld at such a site.
+    # The mark belongs to the site, so no rebind or narrowing of a variable drops it, and a join keeps a site
+    # either arm holds: the mark only ever withholds that reading, whose answer is the narrower one.
     EMPTY_REPEATED_OR_WRITES = {}.compare_by_identity.freeze
     # Issue #1429 — the narrowing a guard leaves on a constant reference (`STDOUT.is_a?(StringIO)`, `if CONFIG`),
     # keyed by the reference's spelling ({Inference::Narrowing.constant_key}: `"STDOUT"`, `"::Foo::BAR"`). A constant
@@ -457,6 +457,13 @@ module Rigor
       @locals[name.to_sym]
     end
 
+    # Issue #1840 — replaces the joined bindings of locals a branch merge only narrowed with their pre-branch
+    # binding ({Inference::UntypedRejoin}). Unlike {#with_local} this is not a write: the value is the one the
+    # branches started from, so every fact, narrowing and mark the join kept about it still holds.
+    def with_rejoined_locals(bindings)
+      rebuild(locals: @locals.merge(bindings).freeze)
+    end
+
     def with_local(name, type)
       bind_local(name, type, keep_marks: false)
     end
@@ -1055,20 +1062,22 @@ module Rigor
       @repeated_or_writes.key?(node)
     end
 
-    # Regex match-data globals (`$~`, `$&`, `$1..$9`, the pre/post-match and last-paren back-references). Narrowed
+    # Regex match-data globals (`$~`, `$&`, `$1..$N`, the pre/post-match and last-paren back-references). Narrowed
     # on a successful-`=~` / `case`-`when` match edge (see `Narrowing#regex_match_predicate_scopes`). They live in
     # the method frame's special-variable slot, which the method's blocks and closures share (issue #1358), so a
     # later call that may run a match in this frame — a match-capable call, a block that may match, a call once
     # the frame has made a closure that may — rebinds every one of them, and `eval_call` forgets the narrowed
     # facts here. Always safe — only drops facts, so a subsequent read falls back to the default `String | nil`.
     # Program-level `$GLOBAL = ...` seeds use other names and are untouched.
-    MATCH_DATA_GLOBALS = %i[$~ $& $` $' $+ $1 $2 $3 $4 $5 $6 $7 $8 $9].freeze
-    private_constant :MATCH_DATA_GLOBALS
+    # Issue #1384 — the numbered groups are matched by name, not listed: a regex may carry more than nine captures, and
+    # `$10` and above are the same slot as `$1`..`$9`, so forgetting must clear them too.
+    MATCH_DATA_GLOBAL_NAME = /\A\$(?:~|&|`|'|\+|[1-9]\d*)\z/
+    private_constant :MATCH_DATA_GLOBAL_NAME
 
     def forget_match_globals
       return self unless match_globals_bound?
 
-      rebuild(globals: @globals.except(*MATCH_DATA_GLOBALS).freeze)
+      rebuild(globals: @globals.reject { |name, _| MATCH_DATA_GLOBAL_NAME.match?(name.name) }.freeze)
     end
 
     # Issue #1361 — this scope with every bound match-data global rebound to `Dynamic[top]`, and an unbound one left
@@ -1079,14 +1088,16 @@ module Rigor
       return self unless match_globals_bound?
 
       untyped = Type::Combinator.untyped
-      rebound = MATCH_DATA_GLOBALS.each_with_object({}) { |name, acc| acc[name] = untyped if @globals.key?(name) }
+      rebound = @globals.each_with_object({}) do |(name, _), acc|
+        acc[name] = untyped if MATCH_DATA_GLOBAL_NAME.match?(name.name)
+      end
       rebuild(globals: @globals.merge(rebound).freeze)
     end
 
     # True when any match-data global holds a binding, which a match edge or {#untyped_match_globals} makes: the only
     # state {#forget_match_globals} can drop, and so the gate on every scan that decides whether to.
     def match_globals_bound?
-      !@globals.empty? && MATCH_DATA_GLOBALS.any? { |name| @globals.key?(name) }
+      !@globals.empty? && @globals.any? { |name, _| MATCH_DATA_GLOBAL_NAME.match?(name.name) }
     end
 
     # Issue #1359 — the last line read, `$_`, lives in the same frame slot as the match globals, and so on the same

data/lib/rigor/sig_gen/generator.rb

@@ -57,7 +57,8 @@ module Rigor
     #   a parameter-only inline `# @rbs` annotation) is the ABSENCE of a return statement, not the author's
     #   word about it — the opposite of `void`. It is treated like no declaration at all: the inferred return
     #   is proposed as `tighter-return`, carrying `untyped` as the declared spelling so `--diff` still shows a
-    #   declaration existed (#995; see {#declared_untyped?}).
+    #   declaration existed (#995; see {#declared_untyped?}). A value literal the body proves (Integer, String,
+    #   Symbol) is widened to its class there unless the `untyped` is only the inline reader's synthesis (#1489).
     # - A `tighter-return` over the class's own declaration replaces the return and nothing else: the rest of
     #   the line is the declaration's, spelled as written, so `--overwrite` never changes which calls the
     #   signature accepts. A declaration with more than one overload, or one spelled as an `alias`, is left
@@ -1416,14 +1417,53 @@ module Rigor
         declared.is_a?(Type::Dynamic)
       end
 
-      # Proposed without {#compare_against_declared}'s tightening guards: a declared `untyped` return carries no
-      # information to weigh {#tighter?} or {#literal_decline?} against, the same position a method with no
-      # declaration at all is in. The line is built as for any tightening ({#tighter_return_line}), and
-      # `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag says one existed.
+      # Proposed without {#tighter?}: a declared `untyped` return carries no information to weigh it against, the
+      # same position a method with no declaration at all is in. Over a declaration the author wrote, though, a
+      # VALUE literal the body proves (`-> 1`, `-> "x"`, `-> :k`) is an implementation detail the `untyped` was
+      # abstracting over, so it is widened to its class (`1 | 2` to `Integer`, `"S" | nil` to `(String | nil)`; #1489).
+      # `nil`, `true` and `false` are honest types and stay, as does a computed `Float`. An `untyped` that is only
+      # the inline reader's synthesis ({#synthesized_declaration?}) is no word of the author's and keeps the
+      # strictest carrier. `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag
+      # says a declaration existed.
       def declared_untyped_candidate(path, def_node, class_name, kind, inferred, method_def, rendered: nil)
+        unless synthesized_declaration?(method_def)
+          widened = widen_value_literals(inferred)
+          unless widened.equal?(inferred)
+            # A `rendered` line was spelled from the unwidened type; there is nothing to rebuild it from.
+            return equivalent(path, def_node, class_name, kind, inferred, "untyped") if rendered
+
+            inferred = widened
+          end
+        end
+
         tighter_return_candidate(path, def_node, class_name, kind, inferred, method_def, "untyped", rendered)
       end
 
+      VALUE_LITERAL_CLASSES = [Integer, String, Symbol].freeze
+      private_constant :VALUE_LITERAL_CLASSES
+
+      # The same object back when nothing needed widening.
+      def widen_value_literals(type)
+        case type
+        when Type::Constant
+          return type unless VALUE_LITERAL_CLASSES.any? { |klass| type.value.instance_of?(klass) }
+
+          Type::Combinator.nominal_of(type.value.class.name)
+        when Type::Union
+          members = type.members.map { |member| widen_value_literals(member) }
+          members.each_with_index.all? { |m, i| m.equal?(type.members[i]) } ? type : Type::Combinator.union(*members)
+        else
+          type
+        end
+      end
+
+      # A declaration only the inline reader's synthesis (a `virtual:` buffer) supplies — ADR-93 gives every `def` an
+      # `untyped` member, annotated or not — is no word of the author's about the return, so it keeps the proposal
+      # a method with no declaration at all gets: the strictest carrier the body proves.
+      def synthesized_declaration?(method_def)
+        method_def.defs.all? { |type_def| type_def.member.location&.buffer&.name.to_s.start_with?("virtual:") }
+      end
+
       def build_declared_return(method_def)
         translated = method_def.method_types.filter_map { |mt| translate_method_type_return(mt) }
         return nil if translated.empty?

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end