rigortype 0.3.9 → 0.4.1

data/lib/rigor/inference/scope_indexer/certainty.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # ADR-119 WD3 — which of a file's method contributions are `possible`: the classifier the def-contribution
+      # producers ({ScopeIndexer#build_methods_and_def_nodes}, {ScopeIndexer#build_discovered_singleton_def_nodes})
+      # consult to fill `possible_discovered_methods` and the `contested_*` siblings.
+      #
+      # A contribution is `certain` when its statement executes whenever the file's top level executes. The certain
+      # regions are:
+      #
+      # - the program's statements, and the bodies of `class`, `module` and `class << self` declarations that are
+      #   themselves certain;
+      # - the block of a meta-new constant write (`K = Class.new do … end`, `Module.new`, `Struct.new`,
+      #   `Data.define`, {ScopeIndexer#meta_new_block_call}) and of a bare factory call
+      #   ({AnonymousMetaClass.block_form_receiver}), when the write or the call is certain: Ruby runs the block once,
+      #   as the new class's body (ADR-119 WD2, "Conditional definers");
+      # - a `begin` WITHOUT a `rescue` clause: its main statements and its `ensure` clause;
+      # - the receiver and arguments of a certain call, so `private def x` and `memoize def x` stay certain.
+      #
+      # Everything else is `possible`: the branches of `if` / `unless` / `case` and the modifiers, loop bodies, the
+      # right operand of `&&` / `||`, every other block and every lambda, `BEGIN` / `END`, a `class X … end if Y`
+      # reopening, and the WHOLE of a `begin` that has a `rescue` clause, its main statements included. That last
+      # rule refines WD3's wording: a rescued raise skips every statement after the raising one, so the main body of
+      # a rescuing `begin` is not certain either, while a `begin` with no rescue either runs its main statements
+      # and `ensure` or propagates the raise out of the file's top level. A `def` inside a method body is never
+      # recorded by the walks (they return at a `DefNode`), so the classifier does not descend there either.
+      #
+      # The answer is an identity Set of the POSSIBLE contribution nodes — the nodes a producer records from — and
+      # {EMPTY} when the file has none, so a file written entirely in certain regions allocates nothing. It is
+      # separate from {MixinAccumulator}, which answers a different question (whether an edge's POSITION is a fact).
+      module Certainty
+        # The answer for a file with no possible contribution.
+        EMPTY = Set.new.compare_by_identity.freeze
+
+        # The nodes a def-contribution producer records from: a `def`, an `alias` / `undef`, a call (`attr_*`,
+        # `define_method`, `alias_method`, `module_function :x`, a factory's members), and the declarations whose
+        # header records members (`class X < Struct.new(:a)`, `X = Struct.new(:a) do … end`).
+        CONTRIBUTIONS = Set[
+          Prism::DefNode, Prism::AliasMethodNode, Prism::UndefNode, Prism::CallNode, Prism::ClassNode,
+          Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode,
+          Prism::ConstantPathOrWriteNode
+        ].freeze
+
+        CONSTANT_WRITES = Set[
+          Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode,
+          Prism::ConstantPathOrWriteNode
+        ].freeze
+
+        # The nodes whose whole subtree is possible.
+        POSSIBLE_ROOTS = Set[
+          Prism::BlockNode, Prism::LambdaNode, Prism::PreExecutionNode, Prism::PostExecutionNode,
+          Prism::RescueModifierNode
+        ].freeze
+        private_constant :CONSTANT_WRITES, :POSSIBLE_ROOTS
+
+        module_function
+
+        # The possible contribution nodes of the tree under `root`, an identity Set ({EMPTY} when none).
+        def possible_nodes(root)
+          classifier = Classifier.new
+          classifier.certain(root)
+          classifier.result
+        end
+
+        # Whether `node` was classified possible in `possible` (a {possible_nodes} answer).
+        def possible?(possible, node)
+          !possible.empty? && possible.include?(node)
+        end
+
+        # One classification walk. `certain` descends a certain region; `possible` marks every contribution in a
+        # subtree, since nothing below a possible node is certain.
+        class Classifier
+          def initialize
+            @possible = nil
+          end
+
+          def result
+            @possible ? @possible.freeze : EMPTY
+          end
+
+          def certain(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+            return unless node.is_a?(Prism::Node)
+            return possible(node) if POSSIBLE_ROOTS.include?(node.class)
+
+            case node
+            when Prism::DefNode then return
+            when Prism::IfNode then return branch(node.predicate, node.statements, node.subsequent)
+            when Prism::UnlessNode then return branch(node.predicate, node.statements, node.else_clause)
+            when Prism::CaseNode, Prism::CaseMatchNode then return case_branches(node)
+            when Prism::WhileNode, Prism::UntilNode then return branch(node.predicate, node.statements)
+            when Prism::ForNode then return branch(node.collection, node.index, node.statements)
+            when Prism::AndNode, Prism::OrNode then return branch(node.left, node.right)
+            when Prism::BeginNode then return begin_block(node)
+            when Prism::CallNode then return call(node)
+            end
+            return if CONSTANT_WRITES.include?(node.class) && meta_new_write?(node)
+
+            node.rigor_each_child { |child| certain(child) }
+          end
+
+          # Marks every contribution of the subtree.
+          def possible(node)
+            return unless node.is_a?(Prism::Node)
+
+            (@possible ||= Set.new.compare_by_identity) << node if CONTRIBUTIONS.include?(node.class)
+            return if node.is_a?(Prism::DefNode)
+
+            node.rigor_each_child { |child| possible(child) }
+          end
+
+          private
+
+          # The first node runs whenever the construct does; the rest may not.
+          def branch(first, *rest)
+            certain(first)
+            rest.each { |node| possible(node) }
+          end
+
+          def case_branches(node)
+            certain(node.predicate)
+            node.conditions.each { |clause| possible(clause) }
+            possible(node.else_clause)
+          end
+
+          # Without a rescue the main statements run (or the raise leaves the file) and `ensure` runs; with one, a
+          # rescued raise skips every statement after the raising one, so all of it is possible.
+          def begin_block(node)
+            return possible_children(node) if node.rescue_clause
+
+            certain(node.statements)
+            possible(node.else_clause)
+            certain(node.ensure_clause)
+          end
+
+          def possible_children(node)
+            node.rigor_each_child { |child| possible(child) }
+          end
+
+          # The receiver and arguments of a certain call run; its block runs as a class body only for a bare
+          # factory call. A safe-navigation call may skip its arguments.
+          def call(node)
+            certain(node.receiver)
+            if node.safe_navigation?
+              possible(node.arguments)
+              possible(node.block)
+              return
+            end
+            certain(node.arguments)
+            block = node.block
+            if block.is_a?(Prism::BlockNode) && AnonymousMetaClass.block_form_receiver(node)
+              certain(block.body)
+            else
+              certain(block)
+            end
+          end
+
+          # A meta-new constant write: the factory's receiver and arguments, and its block as the class body.
+          def meta_new_write?(node)
+            call = ScopeIndexer.meta_new_block_call(node)
+            return false unless call
+
+            certain(call.receiver)
+            certain(call.arguments)
+            block = call.block
+            certain(block.is_a?(Prism::BlockNode) ? block.body : block)
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/class_cvars_collector.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../declaration_walk/traversal"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # The `class_cvars` discovery table (slice 7 phase 6) as a {DeclarationWalk} collector: every
+      # `@@x = …` a `def` body writes, typed under the census scope and unioned per class. Ruby cvars are
+      # shared by the instance and singleton facets, so every `def` counts, `def self.x` included.
+      class ClassCvarsCollector
+        include DeclarationWalk::Collector
+
+        def initialize
+          @table = {}
+        end
+
+        # `@@x` in a `def` resolves through the LEXICAL cref: `Module.nesting` is the same inside a meta-new or
+        # eval block, so the context's `prefix` keys the write and its rebound `self` never does —
+        # `K = Class.new { def m = @@x }` inside `class C` writes `C::@@x`. The walk goes no further in: the
+        # gather reads the body with `def`, `class` and `module` as barriers, and nothing below a `def` reaches
+        # this table.
+        def on_def(node, context)
+          ScopeIndexer.collect_def_cvar_writes(node, context.prefix, context.scope, @table)
+          DeclarationWalk::DECLINE
+        end
+
+        # The table as the discovery index holds it: each class's entry frozen, then the whole.
+        def table
+          @table.transform_values(&:freeze).freeze
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/def_nestings_collector.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../declaration_walk/traversal"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #681's `{Prism::DefNode => Module.nesting}` table as a {DeclarationWalk} collector: the chain every
+      # `def` is declared under, keyed by node identity. A top-level `def` records the empty chain (#716); a `def`
+      # below a header that renders no name records nothing, because no chain survives it.
+      class DefNestingsCollector
+        include DeclarationWalk::Collector
+
+        # The rules `walk_def_nestings` answered differently from the walk, kept so the table stays
+        # byte-identical (ADR-116 WD5). Each is a legacy answer, and #1521 tracks converging it:
+        #
+        # - `factory_block: :ordinary_call` — no bare-factory arm, so a `self::` header in a `Class.new { … }`
+        #   block anchors on the enclosing `self` and the block's parameters are walked (#1521 item 8).
+        # - `lexical_prefix: :nesting_head` — the walker threads no qualified prefix; its meta-new and eval
+        #   splits resolve against `nesting.first` split into segments, which differs from the walk's prefix
+        #   below a compact header and below an unnameable cref (#1521 item 1).
+        # - `unrendered_header: :body_with_lost_nesting` — a header that renders no name (a parse error) walks
+        #   its body alone, with the chain lost unless an unnameable cref encloses it (#1521 item 3).
+        VARIANTS = {
+          factory_block: :ordinary_call,
+          lexical_prefix: :nesting_head,
+          unrendered_header: :body_with_lost_nesting
+        }.freeze
+
+        def initialize
+          @table = {}.compare_by_identity
+        end
+
+        # Nothing below a `def` declares a class or module, so the walk goes no further in for this table.
+        def on_def(node, context)
+          nesting = context.nesting
+          @table[node] = nesting unless nesting.nil?
+          DeclarationWalk::DECLINE
+        end
+
+        def table
+          @table.freeze
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/layered_def_nestings.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #1507 — a file's issue #681 def-nesting table read over the cross-file seed rather than merged into a
+      # copy of it. The copy inserted every `def` in the PROJECT once per analysed file (263 ms of an 18.95 s cold
+      # Mastodon run); a lookup probes at most both layers, and only for a `def` whose body is re-walked.
+      #
+      # Both layers are keyed by node identity, so a same-file declaration and its cross-file twin are distinct keys
+      # and the order cannot change an answer. The file layer is read first all the same, which is what the merge it
+      # replaces did (`merge!(seed)`, then `merge!(file)`), so the answer holds even if a shared parse ever made the
+      # keys overlap.
+      #
+      # It answers what the table's readers ask — `[]` ({ExpressionTyper#recorded_def_nesting}) and `empty?` — and
+      # is deliberately not a Hash: `each`, `key?`, `size` or `==` would have to see both layers, and a Hash holding
+      # one of them would answer those wrong instead of raising.
+      class LayeredDefNestings
+        def initialize(file, seed)
+          @file = file
+          @seed = seed
+          freeze
+        end
+
+        # `fetch` rather than `||`, so presence in the file layer decides, as the later `merge!` did.
+        def [](def_node)
+          @file.fetch(def_node) { @seed[def_node] }
+        end
+
+        def empty?
+          @file.empty? && @seed.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/member_layouts_collector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../declaration_walk/traversal"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # ADR-48's two member-layout tables as one {DeclarationWalk} collector: the ordered members of each
+      # `Data.define` class and of each `Struct.new` class (with its `keyword_init:` flag), in both the subclass
+      # form (`class Point < Data.define(:x, :y)`) and the constant form (`Point = Data.define(:x, :y)`). The
+      # legacy walkers built the two tables in two walks with the same rules; one collector builds both.
+      class MemberLayoutsCollector
+        include DeclarationWalk::Collector
+
+        # The rules the member-layout walkers answered differently from the walk, kept so both tables stay
+        # byte-identical (ADR-116 WD5). Each is a legacy answer, and #1521 tracks converging it:
+        #
+        # - `factory_block: :ordinary_call` — no bare-factory arm, so a `self::` header in a `Class.new { … }`
+        #   block anchors on the enclosing `self` and the block's parameters are walked (#1521 item 8).
+        # - `unrendered_header: :skip` — a header that renders no name (a parse error) stops the walk there:
+        #   neither its parts nor its body are walked (#1521 item 3).
+        VARIANTS = { factory_block: :ordinary_call, unrendered_header: :skip }.freeze
+
+        def initialize
+          @data = {}
+          @struct = {}
+        end
+
+        # A `class Point < Data.define(:x, :y)` header, recorded under the class it names; an unnameable
+        # header (`class D` below `class <<` opens `#<Class:C>::D`, which no name spells) records nothing.
+        def on_declaration(node, _context, body)
+          if node.is_a?(Prism::ClassNode) && !body.singleton_cref
+            ScopeIndexer.record_data_member_layout(@data, body.prefix, node.superclass, allow_outer_block: false)
+            ScopeIndexer.record_struct_member_layout(@struct, body.prefix, node.superclass, allow_outer_block: false)
+          end
+          DeclarationWalk::DESCEND
+        end
+
+        # A `Point = Data.define(:x, :y)` write, recorded under the class the write names. Below an unnameable
+        # cref only a path write still names one.
+        def on_constant_write(node, context)
+          self_owner = context.self_owner
+          unless context.singleton_cref && !ScopeIndexer.meta_new_path_target_nameable?(node, self_owner)
+            child_prefix = ScopeIndexer.meta_new_child_prefix(node, context.prefix, self_owner)
+          end
+          if child_prefix
+            rvalue = ScopeIndexer.meta_new_rvalue(node)
+            ScopeIndexer.record_data_member_layout(@data, child_prefix, rvalue)
+            ScopeIndexer.record_struct_member_layout(@struct, child_prefix, rvalue)
+          end
+          DeclarationWalk::DESCEND
+        end
+
+        # `[data_member_layouts, struct_member_layouts]`, each frozen.
+        def tables
+          [@data.freeze, @struct.freeze]
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/mixin_accumulator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # The accumulator the mixin walks ({ScopeIndexer#mixin_tables}, {ScopeIndexer#extend_tables}) fill: the
+      # per-class module lists as before, plus which mixin edges have no position the tables can vouch for
+      # (`Scope::DiscoveryIndex#unpositioned_mixins`).
+      #
+      # The mixin tables store each class's modules in the order the statements that wrote them run, and that
+      # order is a fact only for a DIRECT statement of the class's own body (or of its `class << self` body),
+      # in a declaration that is itself a direct statement (a top-level statement, or a direct statement of a
+      # direct body): `include M` there runs where it is written, unconditionally. An `include` inside a
+      # method, a block (`class_eval`, `Class.new`, `included do`), a conditional, or a declaration wrapped in
+      # a conditional or a block (`class C; include B; end if X`) runs when that code runs, if it runs at
+      # all, and the receiver form (`Base.prepend(M)`) runs wherever it is called from, so the order the
+      # tables give such an edge is a guess. The walks record those edges as they always did and name them
+      # here, so a reader that depends on ORDER can decline where the order is not known. An edge written
+      # both ways is unpositioned: one guessed copy is enough to move the answer.
+      #
+      # A mixin call the walks CANNOT record (`include helper`, `include(*MODS)`, `send(:include, M)`,
+      # `self.include M`, `C.include(M)`, `singleton_class.include M`, `base.extend M` or
+      # `base.class_eval { include M }` in a `self.included(base)` hook, a name in an argument list beside one
+      # the walk cannot name) still reshapes the ancestry of the class it belongs to, and
+      # leaves the edges the tables did record looking positioned. So it taints the whole owner side with the
+      # {WILDCARD} name instead: an owner side that lists {WILDCARD} has no known order at all.
+      #
+      # The value is `{owner => {include: [names], extend: [names]}}`. `:include` is the instance side
+      # (`include` and `prepend`), `:extend` the singleton side (`extend`, and `include` / `prepend` inside
+      # `class << self`), so an unknown `extend` never taints a class's instance ancestry.
+      #
+      # A Hash (owner => lists), so every walk helper that indexes the accumulator keeps working unchanged.
+      class MixinAccumulator < Hash
+        # The name an owner side lists when a mixin call the walk could not record was written on it.
+        WILDCARD = "*"
+
+        # What {#unpositioned} answers when nothing was noted: one shared frozen table, so the common file
+        # allocates none.
+        EMPTY = {}.freeze
+
+        DIRECT_STATEMENTS = [Prism::CallNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+        private_constant :DIRECT_STATEMENTS
+
+        def initialize
+          super
+          @direct = nil
+          @unpositioned = nil
+          @hook_params = nil
+          @body_blocks = nil
+        end
+
+        # Marks the statements of a body whose own position is a fact — the calls and declarations in them
+        # are the only ones whose position is. The caller marks a declaration's body only when the
+        # declaration was itself marked (or is the file's top level).
+        def direct_body(body)
+          return unless body.is_a?(Prism::StatementsNode)
+
+          body.body.each do |statement|
+            next unless DIRECT_STATEMENTS.any? { |kind| statement.is_a?(kind) }
+
+            (@direct ||= Set.new.compare_by_identity) << statement
+          end
+        end
+
+        # Marks the block-carrying calls that are statements of a class or module body, whatever that declaration
+        # sits in: the only blocks whose `self` the extends walk takes to be the body's own (#1592).
+        def body_statements(body)
+          return unless body.is_a?(Prism::StatementsNode)
+
+          body.body.each do |statement|
+            if statement.is_a?(Prism::CallNode) && statement.block
+              (@body_blocks ||= Set.new.compare_by_identity) << statement
+            end
+          end
+        end
+
+        def body_block?(node)
+          !@body_blocks.nil? && @body_blocks.include?(node)
+        end
+
+        # Runs the block with the parameters of a `self.included(base)`-style hook in scope: a mixin call on
+        # one of them reshapes the class that reached the hook, which this walk cannot name.
+        def with_hook_params(names)
+          saved = @hook_params
+          @hook_params = saved ? saved + names : names
+          yield
+        ensure
+          @hook_params = saved
+        end
+
+        def hook_local?(name)
+          !@hook_params.nil? && @hook_params.include?(name)
+        end
+
+        def direct?(node)
+          !@direct.nil? && @direct.include?(node)
+        end
+
+        # Notes the edges `node` recorded for `owner` on `side`. `complete` is false when an argument named
+        # nothing the walk could record, which leaves the recorded names' neighbours unknown.
+        def note(node, owner, side, targets, complete:)
+          return taint(owner, side) unless complete
+          return if node.receiver.nil? && direct?(node)
+
+          add(owner, side, targets)
+        end
+
+        # Names `owner`'s `side` as having no known order.
+        def taint(owner, side)
+          add(owner, side, [WILDCARD])
+        end
+
+        # `{owner => {side => [names]}}`, frozen, each list de-duplicated.
+        def unpositioned
+          return EMPTY if @unpositioned.nil?
+
+          @unpositioned.transform_values do |sides|
+            sides.transform_values { |names| names.uniq.freeze }.freeze
+          end.freeze
+        end
+
+        private
+
+        def add(owner, side, names)
+          ((@unpositioned ||= {})[owner] ||= {})[side] = ((@unpositioned[owner][side] || []) + names)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/superclasses_collector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../declaration_walk/traversal"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # The as-written superclass table and its issue #682 header-nesting twin (ADR-24 slice 2), as a
+      # {DeclarationWalk} collector: each `class Foo < Bar` header's superclass name and the `Module.nesting`
+      # its header sits in, plus the superclass of a `Class.new(Parent) { … }` block under that anonymous
+      # class's synthetic name (#319). One walk builds both tables, so a caller never pairs a superclass
+      # with a nesting from a different parse.
+      class SuperclassesCollector
+        include DeclarationWalk::Collector
+
+        # The two rules `walk_class_superclasses` answered differently from the walk, kept so both tables stay
+        # byte-identical (ADR-116 WD5). Each is a legacy answer, and #1521 tracks converging it:
+        #
+        # - `factory_block: :ordinary_call` — the legacy walker had no bare-factory arm, so it walked
+        #   `Class.new { … }` as any call, block parameters included, with the enclosing `self`. A
+        #   `class self::E < S` in that block is filed under the enclosing class (`C::E`), a class Ruby never
+        #   creates (#1521 item 8).
+        # - `anonymous_class_path: :outside_class_bodies` — the legacy walker dropped the file path when it
+        #   entered a class/module, meta-new or eval-family body, but not a `class <<` body, so an anonymous
+        #   class created inside a class body is keyed without the path the other tables give it (#1521 item
+        #   11).
+        VARIANTS = { factory_block: :ordinary_call, anonymous_class_path: :outside_class_bodies }.freeze
+
+        def initialize
+          @accumulator = { superclasses: {}, header_nestings: {} }
+          # Read through the class, as the walk reads `factory_block`, so a subclass that overrides `VARIANTS`
+          # gets one answer from both.
+          @path_variant = DeclarationWalk::Collector.variant_of(self.class, :anonymous_class_path)
+        end
+
+        # A header that still names its class records its ancestry: an unnameable one (`class D` below
+        # `class <<`) would publish facts for a `C::D` Ruby never creates. The nesting recorded is the one
+        # OUTSIDE the header, because the header is evaluated before its body is entered.
+        def on_declaration(node, context, body)
+          unless body.singleton_cref
+            ScopeIndexer.record_declaration_ancestry(node, context.nesting, body.prefix, @accumulator)
+          end
+          DeclarationWalk::DESCEND
+        end
+
+        # Only a `Class.new(Parent) { … }` with a literal block records anything, so a call without one is
+        # passed over before the path is looked up.
+        def on_call(node, context)
+          if node.block.is_a?(Prism::BlockNode)
+            path = context.anonymous_class_path(@path_variant)
+            ScopeIndexer.record_anonymous_meta_superclass(node, @accumulator[:superclasses], path)
+          end
+          DeclarationWalk::DESCEND
+        end
+
+        # `[superclasses, header_nestings]`, each frozen, as {ScopeIndexer.declaration_walk_tables} returns
+        # them.
+        def tables
+          [@accumulator[:superclasses].freeze, @accumulator[:header_nestings].freeze]
+        end
+      end
+    end
+  end
+end