rigortype 0.4.2 → 0.4.3

data/lib/rigor/lens/file_reader.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "anchor"
+require_relative "slot"
+require_relative "parameters"
+require_relative "../inference/def_return_typer"
+require_relative "../inference/origin_lookup"
+require_relative "../sig_gen/type_elaborator"
+
+module Rigor
+  module Lens
+    # Reads one analysed file into sites and omissions (docs/internal-spec/lens.md § Files, § Sites). Runs inside
+    # the check run, on the seeded scope index the check rules read, so a body return is the type `check` gives
+    # that body. Every declaration the walk meets is either a site or an omission; none is dropped.
+    class FileReader # rubocop:disable Metrics/ClassLength
+      # A site plus what the member pass needs from it: the declaration node and the contract comments above it.
+      Site = Data.define(:data, :node, :contract_comments)
+      Result = Data.define(:sites, :omissions, :digest)
+      # The running visibility of one class body: Ruby's default for its later `def`s, and whether a toggle the
+      # walk cannot place (under an `if`, a `begin`, a block) leaves that default unknown.
+      # A `detached` body stands for code that is not the class body (a block, a method body, a superclass
+      # expression, an omitted class): its toggles and named calls stay local and change no site.
+      Body = Struct.new(:current, :uncertain, :detached)
+
+      ATTRIBUTE_CALLS = { attr_reader: "reader", attr_writer: "writer", attr_accessor: "accessor" }.freeze
+      OMITTED_CALLS = {
+        alias_method: "alias", define_method: "define_method", module_function: "module_function",
+        refine: "refine"
+      }.freeze
+      VISIBILITY_CALLS = %i[private protected public].freeze
+      CLASS_VISIBILITY_CALLS = { private_class_method: "private", public_class_method: "public" }.freeze
+      BLOCK_NODES = [Prism::BlockNode, Prism::LambdaNode].freeze
+      CONSTANT_WRITES = [
+        Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode,
+        Prism::ConstantPathOrWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantPathAndWriteNode,
+        Prism::ConstantOperatorWriteNode, Prism::ConstantPathOperatorWriteNode
+      ].freeze
+
+      # @param path — the file, relative to the project root
+      # @param spell — callable `(type, owner) -> String` spelling a type as sig-gen writes it
+      def initialize(path:, parse_result:, index:, spell:)
+        @path = path
+        @root = parse_result.value
+        @source = parse_result.source.source
+        @index = index
+        @spell = spell
+        @anchor = Anchor.new(@source, parse_result.comments)
+        @bodies = []
+        @node_visibility = {}.compare_by_identity
+        @sites = []
+        @omissions = []
+      end
+
+      def read
+        walk(@root, [], singleton: false, in_block: false)
+        Result.new(sites: @sites, omissions: @omissions, digest: Lens.digest(@source.b))
+      end
+
+      private
+
+      def walk(node, nesting, singleton:, in_block:)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode then walk_namespace(node, nesting, in_block)
+        when Prism::SingletonClassNode then walk_singleton_class(node, nesting, singleton, in_block)
+        when Prism::DefNode then read_def(node, nesting, singleton, in_block)
+        when Prism::CallNode then walk_call(node, nesting, singleton, in_block)
+        when Prism::AliasMethodNode
+          omit("alias", node.new_name.slice.delete_prefix(":"), node, owner: nesting.last, singleton: singleton)
+        when Prism::MultiWriteNode then walk_multi_write(node, nesting, singleton, in_block)
+        when *CONSTANT_WRITES then walk_constant(node, nesting)
+        else walk_children(node, nesting, singleton, in_block)
+        end
+      end
+
+      def walk_children(node, nesting, singleton, in_block)
+        node.compact_child_nodes.each do |child|
+          if BLOCK_NODES.include?(child.class)
+            detached { walk(child, nesting, singleton: singleton, in_block: true) }
+          else
+            walk(child, nesting, singleton: singleton, in_block: in_block)
+          end
+        end
+      end
+
+      def detached
+        @bodies.push(Body.new("public", false, true))
+        yield
+      ensure
+        @bodies.pop
+      end
+
+      def walk_namespace(node, nesting, in_block)
+        kind = node.is_a?(Prism::ClassNode) ? "class" : "module"
+        name = qualify(nesting, node.constant_path)
+        if node.is_a?(Prism::ClassNode) && node.superclass
+          detached { walk(node.superclass, nesting, singleton: false, in_block: true) }
+        end
+        if in_block || name.nil?
+          omit(kind, name || node.constant_path.slice, node)
+          detached { walk(node.body, nesting, singleton: false, in_block: true) } if node.body
+          return
+        end
+
+        add_site(node, { "kind" => kind, "name" => name, "owner" => nil, "scope" => nil, "attribute" => nil,
+                         "members" => [], "visibility" => nil, "params" => nil, "block" => nil,
+                         "body_return" => nil })
+        walk_body(node.body, nesting + [name], singleton: false)
+      end
+
+      # `class << self` directly in a class or module body opens its singleton class. Any other `class << x`, one
+      # nested in another, or one at the top level (which opens `main`'s) is not modelled.
+      def walk_singleton_class(node, nesting, singleton, in_block)
+        if in_block || singleton || nesting.empty? || !node.expression.is_a?(Prism::SelfNode)
+          omit("singleton_class", nil, node)
+          return detached { walk(node.body, nesting, singleton: singleton, in_block: true) } if node.body
+        end
+
+        walk_body(node.body, nesting, singleton: true)
+      end
+
+      # A class body's statements, tracking the running visibility and `module_function`. A bare `module_function`
+      # makes every later `def` of the body a method on both sides: one site, two members, which revision 1 does
+      # not model.
+      def walk_body(body, nesting, singleton:)
+        return if body.nil?
+
+        @bodies.push(Body.new("public", false, false))
+        statements = body.is_a?(Prism::StatementsNode) ? body.body : [body]
+        module_function_on = false
+        statements.each do |child|
+          if module_function_on && child.is_a?(Prism::DefNode)
+            omit("module_function", child.name.to_s, child, owner: nesting.last, singleton: singleton)
+            next
+          end
+          module_function_on = true if bare_call?(child, :module_function)
+          next if toggle_visibility?(child)
+
+          visibility_call(child, nesting, singleton, direct: true) if visibility_call?(child)
+          walk(child, nesting, singleton: singleton, in_block: false)
+        end
+      ensure
+        @bodies.pop if body
+      end
+
+      # A bare `private` / `protected` / `public` written directly in the body sets the default for later defs.
+      def toggle_visibility?(child)
+        return false unless VISIBILITY_CALLS.any? { |name| bare_call?(child, name) }
+
+        @bodies.last.current = child.name.to_s
+        @bodies.last.uncertain = false
+        true
+      end
+
+      def walk_call(node, nesting, singleton, in_block)
+        if node.receiver.nil? && ATTRIBUTE_CALLS.key?(node.name)
+          read_attribute(node, nesting, singleton, in_block)
+        elsif node.receiver.nil? && OMITTED_CALLS.key?(node.name)
+          return if bare_call?(node, :module_function)
+
+          omit(OMITTED_CALLS.fetch(node.name), first_argument_name(node), node,
+               owner: node.name == :refine ? nil : nesting.last, singleton: singleton)
+          walk_children(node, nesting, singleton, true) unless node.name == :refine
+        else
+          @visited_visibility_calls ||= {}.compare_by_identity
+          if visibility_call?(node) && !@visited_visibility_calls.key?(node)
+            visibility_call(node, nesting, singleton, direct: false)
+          end
+          walk_children(node, nesting, singleton, in_block)
+        end
+      end
+
+      def visibility_call?(node)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+          (VISIBILITY_CALLS.include?(node.name) || CLASS_VISIBILITY_CALLS.key?(node.name))
+      end
+
+      # `private :x`, `private %i[x]`, `private def x`, `private attr_reader :x`, `private_class_method :x`, and a
+      # bare toggle the walk cannot place in the body's statement list. A named call changes members only when it
+      # is written directly in the body (`direct`); one under an `if`, a block or a method body runs at a time
+      # Rigor does not know, so the members it names read unknown.
+      def visibility_call(node, nesting, singleton, direct:)
+        @visited_visibility_calls ||= {}.compare_by_identity
+        @visited_visibility_calls[node] = true
+        direct &&= !@bodies.last&.detached
+        if VISIBILITY_CALLS.include?(node.name)
+          return mark_uncertain if node.arguments.nil?
+
+          apply_visibility(node, node.name.to_s, nesting.last, singleton, direct)
+        else
+          apply_visibility(node, CLASS_VISIBILITY_CALLS.fetch(node.name), nesting.last, true, direct)
+        end
+      end
+
+      def mark_uncertain
+        @bodies.last&.uncertain = true
+      end
+
+      def apply_visibility(node, visibility, owner, singleton, direct)
+        scope = singleton ? "singleton" : "instance"
+        node.arguments.arguments.each do |argument|
+          names = argument_names(argument)
+          if wrapped_declaration?(argument, singleton)
+            @node_visibility[argument] = visibility
+          elsif argument.is_a?(Prism::DefNode)
+            # `private def self.x`: Ruby looks `x` up among instance methods and rejects it, so the result is unknown.
+            @node_visibility[argument] = nil
+          elsif names.nil?
+            # `private *NAMES`: which members change is unknown.
+            unknown_visibility(owner, scope)
+          else
+            names.each { |name| name_visibility(owner, scope, name, direct ? visibility : nil) }
+          end
+        end
+      end
+
+      # A `def` or `attr_*` the visibility call wraps. `private def self.x` is not one: `private` looks the
+      # name up among instance methods.
+      def wrapped_declaration?(argument, singleton)
+        case argument
+        when Prism::DefNode then argument.receiver.nil? || singleton
+        when Prism::CallNode then argument.receiver.nil? && ATTRIBUTE_CALLS.key?(argument.name)
+        else false
+        end
+      end
+
+      # The names a visibility call's argument lists, or nil when it is not a literal list of them.
+      def argument_names(argument)
+        case argument
+        when Prism::SymbolNode, Prism::StringNode then [argument.unescaped]
+        when Prism::ArrayNode
+          names = argument.elements.map { |element| argument_names(element)&.first }
+          names.include?(nil) ? nil : names
+        end
+      end
+
+      def unknown_visibility(owner, scope)
+        @sites.each do |site|
+          site.data["visibility"] = nil if site.data["owner"] == owner && site.data["scope"] == scope
+        end
+        mark_uncertain
+      end
+
+      # `private :x` changes the visibility of the members already defined under that name in this file.
+      def name_visibility(owner, scope, name, visibility)
+        @sites.each do |site|
+          data = site.data
+          next unless data["owner"] == owner && data["scope"] == scope && data["members"].include?(name)
+
+          data["visibility"] = data["members"] == [name] ? visibility : nil
+        end
+      end
+
+      def walk_multi_write(node, nesting, singleton, in_block)
+        (node.lefts + [node.rest&.expression].compact + node.rights).each do |target|
+          next unless target.is_a?(Prism::ConstantTargetNode) || target.is_a?(Prism::ConstantPathTargetNode)
+
+          omit("constant", qualify(nesting, target) || target.slice, target)
+        end
+        walk(node.value, nesting, singleton: singleton, in_block: in_block)
+      end
+
+      def walk_constant(node, nesting)
+        target = node.respond_to?(:target) ? node.target : node
+        name = node.respond_to?(:target) ? qualify(nesting, node.target) : qualify_name(nesting, node.name.to_s)
+        kind = case data_or_struct(node.value)
+               when :data then "data_class"
+               when :struct then "struct_class"
+               else "constant"
+               end
+        omit(kind, name || target.slice, node)
+        walk(node.value, nesting, singleton: false, in_block: true)
+      end
+
+      def read_def(node, nesting, singleton, in_block)
+        scope = def_scope(node, nesting, singleton)
+        if in_block || scope.nil?
+          omit("method", node.name.to_s, node)
+        else
+          owner = nesting.last || "Object"
+          data = { "kind" => "method", "name" => node.name.to_s, "owner" => owner, "scope" => scope.to_s,
+                   "attribute" => nil, "members" => [node.name.to_s],
+                   "visibility" => visibility(node, nesting, scope) }
+          params, block, = Parameters.read(node.parameters, yields: Parameters.yields?(node.body))
+          shape_params, shape_block = Parameters.shape(params, block)
+          data.merge!("params" => shape_params, "block" => shape_block,
+                      "body_return" => body_return(node, owner, scope))
+          add_site(node, data)
+        end
+        # A declaration inside a method body runs only when the method does: not modelled.
+        detached { walk(node.body, nesting, singleton: singleton, in_block: true) } if node.body
+      end
+
+      def read_attribute(node, nesting, singleton, in_block)
+        arguments = node.arguments&.arguments || []
+        names = arguments.map { |arg| arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode) ? arg.unescaped : nil }
+        if in_block || nesting.empty? || names.empty? || names.include?(nil)
+          return omit("attribute", names.compact.first, node)
+        end
+
+        owner = nesting.last
+        scope = singleton ? :singleton : :instance
+        attribute = ATTRIBUTE_CALLS.fetch(node.name)
+        names.each_with_index do |name, ordinal|
+          add_site(node, { "kind" => "attribute", "name" => name, "owner" => owner, "scope" => scope.to_s,
+                           "attribute" => attribute, "members" => attribute_members(name, attribute),
+                           "visibility" => visibility(node, nesting, scope),
+                           "params" => nil, "block" => nil, "body_return" => nil }, ordinal: ordinal)
+        end
+      end
+
+      def add_site(node, data, ordinal: 0)
+        location = node.location
+        anchor = @anchor.for_span(location.start_offset, location.end_offset, location.start_line,
+                                  location.end_line)
+        key = "#{@path}:#{location.start_offset}-#{location.end_offset}:#{ordinal}"
+        tail = { "ordinal" => ordinal, "span" => Lens.span(location),
+                 "contract_span" => Lens.contract_span(anchor.contract_comments), "anchor" => anchor.token,
+                 "contract" => nil }
+        @sites << Site.new(data: { "key" => key }.merge(data).merge(tail), node: node,
+                           contract_comments: anchor.contract_comments)
+      end
+
+      # `owner` / `singleton` name the member the declaration would define, when Rigor can tell.
+      def omit(kind, name, node, owner: nil, singleton: false)
+        member = owner && name
+        @omissions << { "kind" => kind, "owner" => member ? owner : nil,
+                        "scope" => member ? scope_name(singleton) : nil, "name" => name,
+                        "span" => Lens.span(node.location), "reason" => "unsupported_kind" }
+        nil
+      end
+
+      def scope_name(singleton)
+        singleton ? "singleton" : "instance"
+      end
+
+      def attribute_members(name, attribute)
+        case attribute
+        when "reader" then [name]
+        when "writer" then ["#{name}="]
+        else [name, "#{name}="]
+        end
+      end
+
+      # The member's visibility as Ruby gives it: a `private def` / `private attr_reader` wrapper, else the running
+      # default of the body (unknown after a toggle the walk could not place). A class body's toggles do not reach
+      # a `def self.x`. A later `private :x` revises it ({#name_visibility}). A top-level `def` is private.
+      def visibility(node, nesting, scope)
+        return "private" if nesting.empty?
+        return @node_visibility[node] if @node_visibility.key?(node)
+        return "public" if scope == :singleton && node.is_a?(Prism::DefNode) && node.receiver
+
+        body = @bodies.last
+        return nil if body.nil? || body.uncertain
+
+        body.current
+      end
+
+      # `def x` in a class body is an instance method, in `class << self` a singleton one; `def self.x` is a
+      # singleton method of a class body. A `def self.x` inside `class << self`, a top-level `def self.x`, and any
+      # other receiver define methods revision 1 does not model.
+      def def_scope(node, nesting, singleton)
+        return (singleton ? :singleton : :instance) if node.receiver.nil?
+        return nil unless node.receiver.is_a?(Prism::SelfNode)
+        return nil if singleton || nesting.empty?
+
+        :singleton
+      end
+
+      # The body's return under the seeded index, with its parameters as declared (§ Sites).
+      def body_return(node, owner, scope)
+        return Slot.typed("void", "inferred") if scope == :instance && node.name == :initialize
+        return Slot.typed("nil", "inferred") if node.body.nil?
+
+        type = Inference::DefReturnTyper.call(node, @index)
+        return Slot.unavailable("not_computed") if type.nil?
+        return Slot.dynamic("inferred", return_cause(node)) if type.is_a?(Type::Dynamic)
+
+        spelled = @spell.call(type, owner)
+        spelled == "untyped" ? Slot.dynamic("inferred", return_cause(node)) : Slot.typed(spelled, "inferred")
+      rescue StandardError
+        Slot.unavailable("not_computed")
+      end
+
+      def return_cause(node)
+        last = Inference::DefReturnTyper.body_last_expression(node.body)
+        scope = last && (@index[last] || @index[node.body])
+        scope && Inference::OriginLookup.origin_for(scope, last)
+      end
+
+      # The qualified name a constant path declares under `nesting`, or nil when it is not a plain constant path
+      # (`self::Foo`, `expr::Foo`).
+      def qualify(nesting, path)
+        case path
+        when Prism::ConstantReadNode, Prism::ConstantTargetNode then qualify_name(nesting, path.name.to_s)
+        when Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          return path.name.to_s if path.parent.nil?
+
+          parent = qualify(nesting, path.parent)
+          parent && "#{parent}::#{path.name}"
+        end
+      end
+
+      def qualify_name(nesting, name)
+        nesting.empty? ? name : "#{nesting.last}::#{name}"
+      end
+
+      def bare_call?(node, name)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && node.name == name && node.arguments.nil? &&
+          node.block.nil?
+      end
+
+      def first_argument_name(node)
+        argument = node.arguments&.arguments&.first
+        case argument
+        when Prism::SymbolNode, Prism::StringNode then argument.unescaped
+        when Prism::DefNode then argument.name.to_s
+        end
+      end
+
+      def data_or_struct(value)
+        return nil unless value.is_a?(Prism::CallNode) && value.receiver
+
+        receiver = value.receiver.slice.delete_prefix("::")
+        return :data if receiver == "Data" && value.name == :define
+        return :struct if receiver == "Struct" && value.name == :new
+
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/lens/members.rb

@@ -0,0 +1,153 @@
+# 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|
+          site.data["members"].each { |name| groups[[site.data["owner"], site.data["scope"], name]] << site }
+        end
+        result = groups.sort_by { |key, _| key }.map { |key, sites| member(key, sites) }
+        mark_inline_sites
+        result
+      end
+
+      private
+
+      def member(key, sites)
+        owner, scope, name = key
+        contract = @contracts[key]
+        also = @elsewhere.call(owner, scope, name)
+        omitted = @omissions.count { |omission| [omission["owner"], omission["scope"], omission["name"]] == key }
+        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), "sites" => sites.map { |site| site.data["key"] },
+          "also_defined_at" => also, "basis" => basis(contract, single),
+          "overloads" => overloads(contract, sites.first, name, single) }
+      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
+
+      def common_visibility(sites)
+        values = sites.map { |site| site.data["visibility"] }.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)
+        return [] if contract.nil? && single.nil?
+
+        overloads = contract ? contract_overloads(contract, single) : [body_overload(site, name, single)]
+        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)
+        contract.overloads.map do |overload|
+          next overload.except("return_rbs") unless contract.return_inferred
+
+          slot = inferred_return(single)
+          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)
+        return attribute_overload(name, single) if site.data["kind"] == "attribute"
+
+        params, block, head = Parameters.read(site.node.parameters, yields: Parameters.yields?(site.node.body))
+        slot = inferred_return(single)
+        block_rbs = block ? " ?{ (?) -> untyped }" : ""
+        { "rbs" => "#{head}#{block_rbs} -> #{return_spelling(slot)}", "params" => params, "block" => block,
+          "return" => slot }
+      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
+
+      def inferred_return(single)
+        return Slot.unavailable("contested") unless single
+
+        body = 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