rigortype 0.4.2 → 0.4.4

data/lib/rigor/lens/members.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative "slot"
+require_relative "parameters"
+
+module Rigor
+  module Lens
+    # Groups the sites of the requested files into members and fills their signatures (docs/internal-spec/lens.md
+    # § Members). A member is one `(owner, scope, Ruby method name)`; an `attr_accessor :a` site defines `a` and
+    # `a=`. An inferred slot comes from a site's body only when the member has exactly one project definition.
+    class Members
+      # @param sites — every {FileReader::Site} of the requested files
+      # @param omissions — every omission of the requested files
+      # @param contracts — `{[owner, scope, name] => ContractReader::Contract or nil}`
+      # @param elsewhere — callable `(owner, scope, name) -> [{path, line}]`: other project files defining it
+      # @param site_paths — `{site key => absolute path of its file}`, to match an inline contract's buffer
+      def initialize(sites:, omissions:, contracts:, elsewhere:, site_paths:)
+        @sites = sites
+        @omissions = omissions
+        @contracts = contracts
+        @elsewhere = elsewhere
+        @site_paths = site_paths
+      end
+
+      def build
+        groups = Hash.new { |hash, key| hash[key] = [] }
+        @sites.each do |site|
+          Members.scopes_of(site.data).each do |scope|
+            site.data["members"].each { |name| groups[[site.data["owner"], scope, name]] << site }
+          end
+        end
+        @groups = groups
+        result = groups.sort_by { |key, _| key }.map { |key, sites| member(key, sites) }
+        mark_inline_sites
+        result
+      end
+
+      # The scopes a site's members live in: a module function (`module_function`) defines a private instance method
+      # and a public singleton copy from one `def`.
+      def self.scopes_of(data)
+        data["module_function"] ? %w[instance singleton] : [data["scope"]]
+      end
+
+      private
+
+      def member(key, sites)
+        owner, scope, name = key
+        contract = @contracts[key]
+        also = @elsewhere.call(owner, scope, name)
+        omitted = @omissions.count do |omission|
+          [omission["owner"], omission["scope"]] == [owner, scope] && [name, nil].include?(omission["name"])
+        end
+        single = sites.size == 1 && omitted.zero? && also.empty? ? sites.first : nil
+        { "owner" => owner, "scope" => scope, "name" => name, "kind" => member_kind(sites),
+          "visibility" => common_visibility(sites, scope), "sites" => sites.map { |site| site.data["key"] },
+          "also_defined_at" => also, "basis" => basis(contract, single),
+          "overloads" => overloads(contract, sites.first, name, single, scope) }
+      end
+
+      # A member a `def` defines anywhere in the requested files is a method, whatever `attr_*` also names it.
+      def member_kind(sites)
+        sites.any? { |site| site.data["kind"] == "method" } ? "method" : "attribute"
+      end
+
+      def basis(contract, single)
+        return "contract" if contract
+        return "single_site" if single
+
+        "contested"
+      end
+
+      # A module function's singleton copy is public; its instance method carries the site's (private) visibility.
+      def common_visibility(sites, scope)
+        values = sites.map do |site|
+          copy = site.data["module_function"] && scope == "singleton"
+          copy ? site.data["singleton_visibility"] : site.data["visibility"]
+        end.uniq
+        values.size == 1 ? values.first : nil
+      end
+
+      # A contested member without a contract has no overloads: its definitions may differ in arity, and each
+      # method site carries its own parameter list.
+      def overloads(contract, site, name, single, scope)
+        return [] if contract.nil? && single.nil?
+
+        overloads = contract ? contract_overloads(contract, single, scope) : [body_overload(site, name, single, scope)]
+        overloads.map { |overload| overload.merge("rbs" => rbs_unless_unavailable(overload)) }
+      end
+
+      # A contract's overloads. A defaulted return (`inferred-return`) is inferred as for a member without a
+      # contract, and its `untyped` parameters are unknown: Rigor cannot tell an authored `untyped` from a
+      # defaulted one.
+      def contract_overloads(contract, single, scope)
+        contract.overloads.map do |overload|
+          next overload.except("return_rbs") unless contract.return_inferred
+
+          slot = inferred_return(single, scope)
+          params = overload["params"]&.map do |param|
+            param["type"]["type"] == "untyped" ? param.merge("type" => Slot.unavailable("not_computed")) : param
+          end
+          rbs = overload["rbs"]
+          suffix = overload["return_rbs"]
+          rbs = rbs.delete_suffix(suffix) + return_spelling(slot) if rbs && suffix && rbs.end_with?(suffix)
+          overload.except("return_rbs").merge("rbs" => rbs, "params" => params, "return" => slot)
+        end
+      end
+
+      # A member with no contract: its parameters as written, each `untyped` with ADR-75's undeclared-parameter
+      # cause, and the return from its one body.
+      def body_overload(site, name, single, scope)
+        return attribute_overload(name, single) if site.data["kind"] == "attribute"
+
+        node = site.data["alias_of"] ? resolved_alias(site) : site.node
+        return unknown_overload if node.nil?
+
+        params, block, head = Parameters.read(node.parameters, yields: Parameters.yields?(node.body))
+        slot = inferred_return(single, scope)
+        block_rbs = block ? " ?{ (?) -> untyped }" : ""
+        { "rbs" => "#{head}#{block_rbs} -> #{return_spelling(slot)}", "params" => params, "block" => block,
+          "return" => slot }
+      end
+
+      # An alias whose original Rigor cannot pin to one `def`: nothing about its signature is known.
+      def unknown_overload
+        { "rbs" => nil, "params" => nil, "block" => nil, "return" => Slot.unavailable("not_computed") }
+      end
+
+      # The `def` an alias site copied, when its original has no other project definition (one site in the
+      # requested files, no omission naming it, none elsewhere) and no contract. Otherwise which `def` Ruby copied
+      # depends on load order, and `check` reads the last one it saw.
+      def resolved_alias(site)
+        node = site.data["aliased_node"]
+        return nil if node.nil?
+
+        owner = site.data["owner"]
+        old_name = site.data["alias_of"]
+        omitted = @omissions.any? do |omission|
+          [omission["owner"], omission["scope"]] == [owner, "instance"] && [old_name, nil].include?(omission["name"])
+        end
+        olds = @groups.fetch([owner, "instance", old_name], [])
+        return nil if omitted || olds.size != 1 || !@elsewhere.call(owner, "instance", old_name).empty?
+        # The original's contract is not the alias's: whether a declaration carries it over (`alias` in RBS) or
+        # not (`alias_method` under rbs-inline), the alias's undeclared parameters would contradict it.
+        return nil if @contracts[[owner, "instance", old_name]]
+        # An alias of an alias holds only if the alias it copied does.
+        return nil if olds.first.data["alias_of"] && resolved_alias(olds.first).nil?
+
+        node
+      end
+
+      # An attribute without a contract: Rigor does not report the ivar's type in revision 1.
+      def attribute_overload(name, _single)
+        unknown = Slot.unavailable("not_computed")
+        if name.end_with?("=")
+          param = { "name" => nil, "kind" => "required", "type" => Slot.unavailable("not_computed") }
+          { "rbs" => nil, "params" => [param], "block" => nil, "return" => unknown }
+        else
+          { "rbs" => nil, "params" => [], "block" => nil, "return" => unknown }
+        end
+      end
+
+      # A module function's singleton copy has its own return reading (`singleton_body_return`).
+      def inferred_return(single, scope)
+        return Slot.unavailable("contested") unless single
+
+        return Slot.unavailable("not_computed") if single.data["alias_of"] && resolved_alias(single).nil?
+
+        copy = single.data["module_function"] && scope == "singleton"
+        body = copy ? single.data["singleton_body_return"] : single.data["body_return"]
+        return Slot.unavailable("not_computed") if body.nil?
+        return body if Slot.unavailable?(body)
+
+        body.merge("from_site" => single.data["key"])
+      end
+
+      def return_spelling(slot)
+        spelled = Slot.rbs_spelling(slot)
+        spelled.include?(" | ") ? "(#{spelled})" : spelled
+      end
+
+      # `rbs` is null when any slot of the overload is unavailable: an `untyped` there would read as an assertion.
+      def rbs_unless_unavailable(overload)
+        slots = [overload["return"], overload.dig("block", "type")] +
+                (overload["params"] || []).map { |param| param["type"] }
+        slots.any? { |slot| Slot.unavailable?(slot) } ? nil : overload["rbs"]
+      end
+
+      # A site reads `contract: inline` when its own contract comments produced an inline declaration of a member
+      # it defines.
+      def mark_inline_sites
+        @sites.each do |site|
+          path = @site_paths.fetch(site.data["key"])
+          asserted = site.contract_comments.any? { |comment| !comment.location.slice.match?(/\A#\s*@extrbs\b/) }
+          inline = asserted && site.data["members"].any? do |name|
+            contract = @contracts[[site.data["owner"], site.data["scope"], name]]
+            contract&.provenance == "inline" && contract.buffers.any? { |buffer| buffer.end_with?(":#{path}") }
+          end
+          site.data["contract"] = inline ? "inline" : nil
+        end
+      end
+    end
+  end
+end

data/lib/rigor/lens/parameters.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "slot"
+
+module Rigor
+  module Lens
+    # A `def`'s parameter list as slots and as the RBS head sig-gen would write for an undeclared method.
+    module Parameters
+      module_function
+
+      UNDECLARED = "inferred_return_untyped"
+
+      # [params (nil for an argument-forwarding list), block or nil, "(…)" head]. A definition takes a block when
+      # it declares `&blk` or `yields` (its body yields).
+      def read(node, yields: false)
+        block = yields ? undeclared_block : nil
+        return [[], block, "()"] if node.nil?
+        return [nil, block, "(?)"] if node.keyword_rest.is_a?(Prism::ForwardingParameterNode)
+
+        entries = entries(node)
+        params = entries.map { |kind, name| { "name" => name&.to_s, "kind" => kind, "type" => undeclared } }
+        block = undeclared_block if node.block
+        [params, block, "(#{entries.map { |kind, name| spell(kind, name) }.join(', ')})"]
+      end
+
+      # `[kind, name]` per parameter, in declaration order.
+      def entries(node)
+        node.requireds.map { |param| ["required", name_of(param)] } +
+          node.optionals.map { |param| ["optional", param.name] } +
+          rest(node.rest) +
+          node.posts.map { |param| ["post", name_of(param)] } +
+          node.keywords.map { |param| [keyword_kind(param), param.name] } +
+          keyword_rest(node.keyword_rest)
+      end
+
+      def undeclared
+        Slot.dynamic("inferred", UNDECLARED)
+      end
+
+      def undeclared_block
+        { "required" => false, "type" => undeclared }
+      end
+
+      # Whether a `def` body yields, outside the bodies whose `yield` belongs elsewhere: a nested `def`, a lambda,
+      # a `define_method` block.
+      def yields?(node)
+        return false if node.nil?
+        return true if node.is_a?(Prism::YieldNode)
+        return false if node.is_a?(Prism::DefNode) || node.is_a?(Prism::LambdaNode)
+        return false if node.is_a?(Prism::CallNode) && node.name == :define_method && node.receiver.nil?
+
+        node.compact_child_nodes.any? { |child| yields?(child) }
+      end
+
+      # The shape of a parameter list: names and kinds, with every type null (lens.md § Sites).
+      def shape(params, block)
+        [params&.map { |param| param.merge("type" => nil) }, block&.merge("type" => nil)]
+      end
+
+      def name_of(param)
+        param.respond_to?(:name) ? param.name : nil
+      end
+
+      def keyword_kind(param)
+        param.is_a?(Prism::RequiredKeywordParameterNode) ? "keyreq" : "key"
+      end
+
+      def rest(node)
+        node.is_a?(Prism::RestParameterNode) ? [["rest", node.name]] : []
+      end
+
+      def keyword_rest(node)
+        node.is_a?(Prism::KeywordRestParameterNode) ? [["keyrest", node.name]] : []
+      end
+
+      def spell(kind, name)
+        label = name ? " #{name}" : ""
+        case kind
+        when "required", "post" then "untyped#{label}"
+        when "optional" then "?untyped#{label}"
+        when "rest" then "*untyped#{label}"
+        when "keyreq" then "#{name}: untyped"
+        when "key" then "?#{name}: untyped"
+        when "keyrest" then "**untyped#{label}"
+        end
+      end
+    end
+  end
+end

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,322 @@
+# 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 # rubocop:disable Metrics/ClassLength
+      # 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
+          read_constant_value(site, scope) if site.data["kind"] == "constant"
+          Members.scopes_of(site.data).product(site.data["members"]).each do |member_scope, name|
+            read_contract(site.data["owner"], member_scope, name, scope)
+          end
+        end
+        @captured[absolute] = reader
+      end
+
+      # The constant's type as `check` reads it ({Reflection.constant_type_for}): the value the project's source
+      # publishes for the name (every write joined, a mutated one widened) over any declaration, else its RBS
+      # declaration, else unknown.
+      def read_constant_value(site, scope)
+        name = site.data["name"]
+        published = scope.in_source_constants[name]
+        site.data["value"] =
+          if published
+            published_slot(published, scope.environment)
+          else
+            declared_slot(site, contract_reader(scope.environment).read_constant(name, scope.environment))
+          end
+      end
+
+      # The rbs-inline plugin declares every constant of a file it reads, typing an unannotated one from its
+      # literal (`[]` as `Array[untyped]`), and reads only a `#:` trailing the assignment as its type: an inline
+      # declaration is the constant's own only when that is the site's one contract comment.
+      def declared_slot(site, declared)
+        return Slot.unavailable("not_computed") if declared.nil?
+        return Slot.unavailable("not_computed") if declared["provenance"] == "inline" && !trailing_type?(site)
+
+        declared
+      end
+
+      def trailing_type?(site)
+        comments = site.contract_comments
+        comments.size == 1 && comments.first.location.start_line == site.node.location.end_line &&
+          comments.first.location.slice.start_with?("#:")
+      end
+
+      def published_slot(type, environment)
+        return Slot.dynamic("inferred", nil) if type.is_a?(Type::Dynamic)
+
+        spelled = speller(environment).call(type, nil)
+        spelled == "untyped" ? Slot.dynamic("inferred", nil) : Slot.typed(spelled, "inferred")
+      rescue StandardError
+        Slot.unavailable("not_computed")
+      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