rigortype 0.4.2 → 0.4.3

data/lib/rigor/inference/refined_dispatch.rb

@@ -20,10 +20,18 @@ module Rigor
     #
     # Issue #1740 — {OwnMethod} shares {.levels} with the walk below and asks the opposite question for the two
     # argument checks: does the receiver's own method answer ahead of every refinement in effect?
+    #
+    # Issue #1752 — a class object is walked through its own lookup ({ClassObject}): its singleton class and each
+    # superclass's, then `Class`, `Module`, `Object`, `Kernel` and `BasicObject`, so a refinement of `Object` answers
+    # `Integer.oo` while `Integer.sqrt` keeps answering ahead of one.
     module RefinedDispatch
       # The refinement that answers: `module_name` refines `refined_class` (a class or module on the walk).
       Winner = Data.define(:module_name, :refined_class)
 
+      # Issue #1752 — the singleton class `#<Class:of>` as an entry of a class object's walk ({ClassObject}): it
+      # defines the name through `of`'s own singleton methods, and no refinement table key names it.
+      SingletonClass = Data.define(:of)
+
       # The answer when the in-effect list carries {InEffectRefinements::UNKNOWN} and some refinement defines the
       # name on a class the walk reaches: any of them may answer.
       UNKNOWN = :unknown
@@ -37,14 +45,16 @@ module Rigor
       def wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
 
       # A {Winner}, {UNKNOWN}, or nil when no in-effect refinement answers `method_name` on an instance of
-      # `class_name` (the class's own lookup does). `list` is the call site's in-effect refinements.
+      # `class_name` (the class's own lookup does), or with `kind: :singleton` on the class object `class_name`
+      # itself (issue #1752). `list` is the call site's in-effect refinements.
       #
       # ADR-121 WD7 — a row the walk could not read never yields a {Winner}: an in-effect module's row for the name
       # whose class the walk could not name reaches every receiver, and a names-wildcard row of a level the walk
       # reaches before a definer may define the name, so both answer {UNKNOWN}. So does a winner whose module shares
       # its last segment with another listed module (A1): which of a `using`'s declared candidates Ruby finds can
-      # depend on load order.
-      def winner(scope, class_name, method_name, list)
+      # depend on load order. A class object's walk always ends at `Object`, so where it cannot be read a row that
+      # may sit on it answers {UNKNOWN} too.
+      def winner(scope, class_name, method_name, list, kind: :instance)
         refinements = scope.discovered_refinements
         return UNKNOWN if class_unknown_row?(scope, refinements, method_name, list)
 
@@ -53,13 +63,26 @@ module Rigor
         unknown = list.include?(InEffectRefinements::UNKNOWN)
         return nil if targets.nil? && unread.nil? && !unknown
 
-        levels = levels(scope, class_name)
+        levels = levels(scope, class_name, kind: kind)
+        return unread_class_object(scope, refinements, method_name, list) if levels.nil? && kind == :singleton
         return nil if levels.nil?
         return UNKNOWN if unknown && unknown_reaches?(scope, refinements, method_name, levels)
 
         walk_targets(scope, levels, method_name, [targets, unread], list)
       end
 
+      # {UNKNOWN} when some row for `method_name` (or a names-wildcard row) that `list` puts in effect, or any row
+      # under the unknown marker, names a class or module a class object may reach ({ClassObject.reachable?}).
+      def unread_class_object(scope, refinements, method_name, list)
+        unknown = list.include?(InEffectRefinements::UNKNOWN)
+        reaches = refinements.any? do |refined, methods|
+          rows = [methods[method_name], methods[wildcard]].compact
+          !rows.empty? && (unknown || rows.any? { |modules| in_effect?(modules, list) }) &&
+            ClassObject.reachable?(scope, refined)
+        end
+        reaches ? UNKNOWN : nil
+      end
+
       def walk_targets(scope, levels, method_name, (targets, unread), list)
         return nil if targets.nil? && unread.nil?
 
@@ -165,20 +188,40 @@ module Rigor
       # refinement first, as any level is; past that, the mixin may define the name, so a refinement further up the
       # walk may or may not win and the answer is {UNKNOWN}, never the replaced method's. ADR-121 WD7: a level an
       # in-effect module has a names-wildcard row for (`unread`) may define the name too, so it answers {UNKNOWN}.
+      #
+      # Issue #1752 — on a class object's walk a singleton level that only an entry no table names may answer
+      # (`:continue_unsure`) makes a refinement reached past it {UNKNOWN}: that entry may define the name.
       def walk(scope, levels, method_name, targets, unread)
-        levels.each_with_index do |(level_class, entries, mixed), index|
-          return UNKNOWN if level_class && unread.key?(level_class)
-
-          refining = level_class && targets[level_class]
-          return Winner.new(module_name: refining, refined_class: level_class) if refining
-          return targeted_after?(levels, index, targets, unread) ? UNKNOWN : nil if mixed
+        unsure = false
+        levels.each_index do |index|
+          answer = level_answer(scope, levels, index, method_name, [targets, unread])
+          next unsure = true if answer == :continue_unsure
+          next if answer == :continue
 
-          answer = walk_entries(scope, entries, level_class, method_name, targets, unread)
-          return answer unless answer == :continue
+          return unsure && answer.is_a?(Winner) ? UNKNOWN : answer
         end
         nil
       end
 
+      def level_answer(scope, levels, index, method_name, (targets, unread))
+        level_class, entries, mixed, every = levels[index]
+        return UNKNOWN if level_class && unread.key?(level_class)
+
+        refining = level_class && targets[level_class]
+        return Winner.new(module_name: refining, refined_class: level_class) if refining
+        return targeted_after?(levels, index, targets, unread) ? UNKNOWN : nil if mixed
+
+        walk_level(scope, [entries, every], level_class, method_name, [targets, unread])
+      end
+
+      def walk_level(scope, (entries, every), level_class, method_name, (targets, unread))
+        if level_class.is_a?(SingletonClass)
+          return ClassObject.walk_level(scope, every || entries, method_name, targets, unread)
+        end
+
+        walk_entries(scope, entries, level_class, method_name, targets, unread)
+      end
+
       # A level's prepended modules, its own method and its included modules, in that order: `:continue` when none
       # answers, so the walk moves on.
       def walk_entries(scope, entries, level_class, method_name, targets, unread)
@@ -205,7 +248,10 @@ module Rigor
       # name. `every entry` (project levels only) is the level's entries in lookup order with each one that
       # neither the project's resolver nor RBS can name kept as its candidate names (an Array) where `entries`
       # leaves it out: the typer never reads it, and {OwnMethod} declines where a refinement may name one.
-      def levels(scope, class_name)
+      # `kind: :singleton` answers the class object `class_name` instead ({ClassObject.levels}, issue #1752).
+      def levels(scope, class_name, kind: :instance)
+        return ClassObject.levels(scope, class_name) if kind == :singleton
+
         environment = scope.environment
         return rbs_levels(scope, class_name) if environment&.class_known?(class_name)
 
@@ -257,8 +303,9 @@ module Rigor
 
       # Does `name` define `method_name` on its instance side itself: a project `def` (its dependency edge recorded
       # through `Scope#user_def_for`), another project definer (`attr_*`, `define_method`), or an RBS declaration
-      # written on `name` rather than on an ancestor?
+      # written on `name` rather than on an ancestor? A {SingletonClass} asks its own singleton methods.
       def defines?(scope, name, method_name)
+        return ClassObject.defines?(scope, name.of, method_name) if name.is_a?(SingletonClass)
         return true if scope.user_def_for(name, method_name)
         return true if scope.discovered_method?(name, method_name, :instance)
 
@@ -269,4 +316,5 @@ module Rigor
   end
 end
 
+require_relative "refined_dispatch/class_object"
 require_relative "refined_dispatch/own_method"

data/lib/rigor/inference/repeated_or_writes.rb

@@ -20,6 +20,8 @@ module Rigor
     # `cache = {}; [1, 2].find { |e| (cache[:first] ||= e) == 2 }` answered its own `2`, where Ruby keeps the
     # first iteration's `1`, folded `find` to `2` and reported `found == 2` always-truthy. The pass marks the
     # sites this module returns (`Scope#with_repeated_or_writes`), and the reading is withheld at a marked site.
+    # `StatementEvaluator` types a repeating body from one entry scope too — its statement pass and every ADR-56
+    # write-back pass — and marks the generic pass's sites there (issue #1336).
     #
     # The mark is per site, not per receiver, because nothing about the receiver's type can say that its slot
     # was filled: `{}` widens to `Hash[Dynamic[top], Dynamic[top]]`, a bare `Hash.new` is not widened at all, and

data/lib/rigor/inference/scope_indexer.rb

@@ -101,13 +101,17 @@ module Rigor
       #   bodies from their CONVERGED bindings so per-line probes
       #   (`rigor annotate`) reflect the post-writeback state, not the
       #   cap-N intermediate constants. Off for the check path.
+      # @param widen_clauses — check-path flag (issue #1231): a rescue or
+      #   `ensure` clause records the variables the `begin` body writes as
+      #   `Dynamic[top]`. Off for every other reader, so parameter inference
+      #   and sig-gen observe the clause's plain entry.
       # @return identity-comparing
       #   table whose default value is `default_scope`.
       # The no-op re-anchoring table (#722 residue 2): shared so the overwhelmingly common
       # nothing-to-re-anchor walk allocates none.
       EMPTY_RENAMES = {}.freeze
 
-      def index(root, default_scope:, converged_loop_recording: false) # rubocop:disable Metrics/AbcSize
+      def index(root, default_scope:, converged_loop_recording: false, widen_clauses: false) # rubocop:disable Metrics/AbcSize
         # Slice A-declarations. Build the declaration overrides first so every scope handed to the StatementEvaluator
         # already carries the table; structural sharing through `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
@@ -194,7 +198,8 @@ module Rigor
 
         on_enter = ->(node, scope) { table[node] = scope }
         StatementEvaluator.new(scope: seeded_scope, on_enter: on_enter,
-                               converged_loop_recording: converged_loop_recording).evaluate(root)
+                               converged_loop_recording: converged_loop_recording,
+                               widen_clauses: widen_clauses).evaluate(root)
 
         propagate(root, table, seeded_scope)
         table
@@ -3990,6 +3995,7 @@ module Rigor
           if methods_acc.mentions_refine? && methods_acc.refine_in?(location.start_offset, location.end_offset)
             node.rigor_each_child { |child| census_scan(child, qualified_prefix, methods_acc) }
           end
+          record_foreign_singleton_def(node, qualified_prefix, owner_prefix, methods_acc.at(node))
           unless def_owner_prefix&.empty? || defs_singleton == :unnameable ||
                  (singleton_cref && owner_prefix.empty?)
             singleton_def = in_singleton_class || defs_singleton
@@ -4729,6 +4735,50 @@ module Rigor
         acc[:deferred_ranges][path] = build_deferred_ranges(root)
         record_class_sources(acc[:class_sources], path, root, superclasses, includes, file_def_nodes,
                              acc[:compact_headers])
+        record_singleton_class_sources(acc[:singleton_class_sources], path, root)
+      end
+
+      # `{name => Set[path]}` for a bundle's name list (a bundle written before the list existed has none).
+      def bundle_path_sets(names, path) = (names || []).to_h { |name| [name, Set[path]] }
+
+      # Issue #1752 — the constants a `class << Const` body opens in this file, and those whose singleton side a call
+      # there may rewrite ({#singleton_side_call?}). Such a body records facts about
+      # `Const`'s singleton class (a `remove_method`, a `def`) without declaring `Const`, so it stays out of
+      # `class_sources` (whose readers take a name there as one the project declares) and joins only the per-file
+      # class-declaration sets the incremental `class:` edges diff (`Runner#class_declarations`).
+      def record_singleton_class_sources(sources, path, root)
+        collect_singleton_class_targets(root, []) { |name| (sources[name] ||= Set.new) << path }
+      end
+
+      def collect_singleton_class_targets(node, lexical_prefix, &)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          prefix = Source::ConstantPath.declaration_prefix(lexical_prefix, node.constant_path)
+          node.body && prefix && collect_singleton_class_targets(node.body, prefix, &)
+          return
+        when Prism::SingletonClassNode
+          rendered = singleton_receiver_constant_name(node.expression)
+          yield eval_constant_receiver_prefix(node, node.expression, rendered, lexical_prefix).join("::") if rendered
+        when Prism::CallNode
+          yield_singleton_side_constant(node, node.receiver, lexical_prefix, &) if singleton_side_call?(node)
+        end
+        node.rigor_each_child { |child| collect_singleton_class_targets(child, lexical_prefix, &) }
+      end
+
+      # A call on a constant that may rewrite its singleton side (`Const.singleton_class`,
+      # `Const.define_singleton_method`, `Const.extend(M)`, `Const.instance_eval { … }`) records facts about `Const`'s
+      # singleton methods the refinement walk reads from a file that need not declare `Const`, so the file joins the
+      # constant's set too. Written inside `Const`'s own body, the name is in the file's set already; a `def Const.x`
+      # files its own `method:` key.
+      def singleton_side_call?(node)
+        node.name == :singleton_class || surface_rewriting_call?(node)
+      end
+
+      def yield_singleton_side_constant(node, receiver, lexical_prefix)
+        return unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+        rendered = singleton_receiver_constant_name(receiver)
+        yield eval_constant_receiver_prefix(node, receiver, rendered, lexical_prefix).join("::") if rendered
       end
 
       def build_deferred_ranges(root)
@@ -7160,6 +7210,7 @@ module Rigor
         return record_module_function(node, current_class, accumulator, in_singleton) if node.name == :module_function
 
         taint_opaque_eval(node, current_class, accumulator)
+        return if singleton_class_rewrite_tainted?(node, qualified_prefix, current_class, accumulator)
 
         kind, _arguments, via_send = mixin_call_view(node)
         return if kind.nil?
@@ -7172,6 +7223,49 @@ module Rigor
         effects.each { |owner, side| accumulator.taint(owner, side) }
       end
 
+      # Issue #1752 — a call that rewrites a singleton class reached through `singleton_class` (`singleton_class.
+      # class_eval { def x }`, `singleton_class.send(:define_method, :x)`, `Const.singleton_class.prepend(M)`,
+      # `Const.singleton_class.send(:include, M)`) puts methods or modules on that singleton class that no edge
+      # records, so its singleton side is unpositioned: the owner is the enclosing class for a bare or `self.`
+      # receiver, else the constant. True when it tainted.
+      def singleton_class_rewrite_tainted?(node, qualified_prefix, current_class, accumulator)
+        receiver = node.receiver
+        return false unless singleton_class_of_receiver?(receiver) && surface_rewriting_call?(node)
+        return false if singleton_class_named_call?(node)
+
+        owner = singleton_class_owner(node, receiver.receiver, qualified_prefix, current_class)
+        return false if owner.nil?
+
+        accumulator.taint(owner, :extend)
+        true
+      end
+
+      # A bare, `self.` or constant receiver's `singleton_class` call.
+      def singleton_class_of_receiver?(receiver)
+        receiver.is_a?(Prism::CallNode) && receiver.name == :singleton_class && receiver.arguments.nil?
+      end
+
+      # An `attr_*` on a singleton class (`singleton_class.attr_accessor :conf`) rewrites only the names it spells, so
+      # it makes those names' singleton envelopes opaque ({#record_singleton_class_names}) and leaves the rest of the
+      # singleton side readable. An `attr_*` with a name it does not spell as a literal (`attr_accessor(*KEYS)`, a
+      # block's variable), and an `alias_method` or `define_method` there, still taint the side: the own-definer read
+      # would otherwise answer the body Ruby replaced (`definer_resolution_witness_spec.rb`).
+      def singleton_class_named_call?(node)
+        arguments = node.arguments&.arguments || []
+        ATTR_MACROS.include?(node.name) && !arguments.empty? &&
+          arguments.all? { |argument| literal_method_name(argument) }
+      end
+
+      def singleton_class_owner(node, object, qualified_prefix, current_class)
+        return current_class if object.nil? || object.is_a?(Prism::SelfNode)
+
+        rendered = Source::ConstantPath.qualified_name_or_nil(object)
+        return nil if rendered.nil?
+        return rendered if Source::ConstantPath.rooted?(object) || qualified_prefix.empty?
+
+        eval_constant_receiver_prefix(node, object, rendered, qualified_prefix).join("::")
+      end
+
       # The bare `module_function` toggle: the module extends itself. A direct statement only.
       def record_module_function(node, current_class, accumulator, in_singleton)
         return unless current_class && node.receiver.nil? && !in_singleton && ModuleFunctionState.extends_self?(node)
@@ -7758,6 +7852,42 @@ module Rigor
           constant_receiver_candidates(receiver, qualified_prefix).each do |name|
             record_surface_mark(tables, name, Scope::DiscoveryIndex::ENVELOPE_DYNAMIC_MARK)
           end
+        elsif singleton_class_of_receiver?(receiver) && singleton_class_named_call?(node)
+          record_singleton_class_names(node, receiver.receiver, qualified_prefix, tables)
+        end
+      end
+
+      # Issue #1752 — the names a {#singleton_class_named_call?} rewrites on its singleton class's owner, each
+      # singleton envelope opaque: the evidence the refinement typer reads as a rewritten singleton name.
+      def record_singleton_class_names(node, object, qualified_prefix, tables)
+        current_class = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
+        owner = singleton_class_owner(node, object, qualified_prefix, current_class)
+        return if owner.nil?
+
+        (node.arguments&.arguments || []).each do |argument|
+          method_name = literal_method_name(argument)
+          next unless method_name
+
+          names = [method_name]
+          names << :"#{method_name}=" if %i[attr_writer attr_accessor].include?(node.name)
+          names.each do |name|
+            record_envelope(tables.envelopes, owner, [:singleton, name], Source::ParameterEnvelope::OPAQUE)
+            contest_envelope(tables, owner, [:singleton, name]) unless tables.certain
+          end
+        end
+      end
+
+      # Issue #1752 — `def Const.x` whose receiver is not the lexical `self` (written at the top level or in another
+      # class's body) defines `Const`'s singleton method, which no table files under `Const`: its singleton name's
+      # envelope turns opaque, the evidence the refinement typer reads as a rewritten singleton name.
+      def record_foreign_singleton_def(node, qualified_prefix, owner_prefix, tables)
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+        return if def_receiver_targets_lexical_self?(receiver, owner_prefix)
+
+        constant_receiver_candidates(receiver, qualified_prefix).each do |name|
+          record_envelope(tables.envelopes, name, [:singleton, node.name], Source::ParameterEnvelope::OPAQUE)
+          contest_envelope(tables, name, [:singleton, node.name]) unless tables.certain
         end
       end
 
@@ -8804,6 +8934,9 @@ module Rigor
         merge_header_nestings(acc[:header_nestings], file_index[:header_nestings] || {})
         fold_mixin_lists(acc, file_index)
         file_index[:class_sources].each { |cn, files| (acc[:class_sources][cn] ||= Set.new).merge(files) }
+        (file_index[:singleton_class_sources] || {}).each do |cn, files|
+          (acc[:singleton_class_sources][cn] ||= Set.new).merge(files)
+        end
         # Issue #722 residue 2 — a pre-#722 seed bundle carries no candidates; the SCHEMA bump makes such a
         # blob a cold rebuild, but default so any in-flight fold stays total.
         acc[:compact_headers].merge!(file_index[:compact_headers] || {})
@@ -8892,6 +9025,7 @@ module Rigor
           # data, so the bundle stays Marshal-clean and a warm file joins the envelopes its cold walk records.
           parameter_envelopes: file_index[:parameter_envelopes],
           class_source_names: file_index[:class_sources].keys,
+          singleton_class_source_names: (file_index[:singleton_class_sources] || {}).keys,
           # Issue #722 residue 2 — plain data, so the bundle stays Marshal-clean and a warm incremental file
           # re-anchors its compact headers the way a cold walk of it does.
           compact_headers: file_index[:compact_headers],
@@ -8916,7 +9050,7 @@ module Rigor
       # ADR-85 WD2 — reconstitutes a cached bundle into a single-file index {#fold_file_index} folds: the
       # def-node triples become {DefHandle}s bound to this file's `path`, and the class-source names become a
       # `{name => Set[path]}` table (the shape `accumulate_project_index` produces).
-      def bundle_to_file_index(bundle, path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity -- one read per bundle slot
+      def bundle_to_file_index(bundle, path) # rubocop:disable Metrics/AbcSize -- one read per bundle slot
         {
           def_nodes: bundle_defs_to_handles(bundle[:def_nodes], path),
           singleton_def_nodes: bundle_defs_to_handles(bundle[:singleton_def_nodes], path),
@@ -8937,7 +9071,8 @@ module Rigor
           method_visibilities: bundle[:method_visibilities],
           methods: bundle[:methods],
           parameter_envelopes: bundle[:parameter_envelopes] || {},
-          class_sources: bundle[:class_source_names].to_h { |name| [name, Set[path]] },
+          class_sources: bundle_path_sets(bundle[:class_source_names], path),
+          singleton_class_sources: bundle_path_sets(bundle[:singleton_class_source_names], path),
           compact_headers: bundle[:compact_headers] || {},
           # Issue #644 — a pre-#644 bundle carries no census; the SCHEMA bump makes such a blob a cold
           # rebuild, but default so any in-flight fold stays total.
@@ -8987,7 +9122,7 @@ module Rigor
           method_visibilities: {},
           methods: {},
           deferred_ranges: {},
-          parameter_envelopes: {}, class_sources: {},
+          parameter_envelopes: {}, class_sources: {}, singleton_class_sources: {},
           # Issue #722 residue 2 — compact-header re-anchor candidates, adjudicated in {#finalize_def_index}.
           compact_headers: {},
           constant_writes: {},