rigortype 0.4.5 → 0.4.6

data/lib/rigor/analysis/check_rules/ivar_write_collector.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "rule_walk"
+require_relative "../../scope/resolution_chain"
 require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
 
@@ -37,36 +38,54 @@ module Rigor
         # `def` that sits directly in a class / module body, never one nested in another `def`. On the
         # shared full DFS that prune becomes the `:inside_def` gate; the enclosing class / module name stack
         # the legacy walk threaded as `qualified_prefix` is now `context.qualified_prefix`.
-        NODE_CLASSES = [Prism::DefNode].freeze
+        #
+        # ADR-125 — the walk also visits class-body `CallNode`s (a `def` body is gated off), to record the
+        # macro calls whose literal arguments name a method (`before_action :load_roles`).
+        NODE_CLASSES = [Prism::DefNode, Prism::CallNode].freeze
         RULE_WALK_GATES = %i[inside_def detached_ivar_facet].freeze
 
-        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:, declared:}>]]`.
-        # Empty when the tree has no qualifying writes. `declared` is the translated type of the class's RBS
-        # declaration of the ivar — an `@x: T` member or the slot an `attr_*` member implies, own or
-        # inherited — and nil when the RBS declares none.
+        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:, declared:,
+        # method_name:, visibility:, per_invocation:, action:}>]]`. Empty when the tree has no qualifying writes.
+        # `declared` is the translated type of the class's RBS declaration of the ivar — an `@x: T` member or
+        # the slot an `attr_*` member implies, own or inherited — and nil when the RBS declares none.
+        #
+        # ADR-125 — `method_name` is the enclosing `def`'s name and `visibility` its instance visibility
+        # (`:public` / `:protected` / `:private`, or nil when the discovery table has no settled answer).
+        # `per_invocation` is whether the class is, or descends from, a class a loaded plugin declares in
+        # `per_invocation_classes:`. `action` is whether the enclosing method is one of that class's entry
+        # points: public, and named by none of the declaring plugin's `per_invocation_non_action_macros:` in a
+        # class body of this file (`before_action :load_roles`, `helper_method :current_roles`).
         def initialize(scope_index)
           @scope_index = scope_index
           @accumulator = {}
+          @per_invocation = {}
+          @macro_arguments = {}
         end
 
         # Legacy single-collector walk — kept as the oracle the ADR-53 Track B equivalence harness compares
         # {RuleWalk} against; deleted when Track B completes.
         def collect(root)
           walk(root, [])
-          @accumulator.transform_values(&:freeze).freeze
+          results
         end
 
         # {RuleWalk} entry point: the legacy walk's per-`def` logic, invoked at each class-/module-body `def`
         # under the shared traversal contract. `collect_def_writes`' verbatim body reads the enclosing class
         # prefix from `context.qualified_prefix`.
-        def visit(def_node, context)
-          collect_def_writes(def_node, context.qualified_prefix)
+        def visit(node, context)
+          if node.is_a?(Prism::CallNode)
+            record_macro_call(node, context.qualified_prefix)
+          else
+            collect_def_writes(node, context.qualified_prefix)
+          end
         end
 
         # The accumulated result, frozen the same way `#collect` returns it — used by {RuleWalk}-driven
         # callers after the walk completes.
         def results
-          @accumulator.transform_values(&:freeze).freeze
+          @accumulator.to_h do |class_name, writes_by_ivar|
+            [class_name, writes_by_ivar.transform_values { |writes| with_actions(class_name, writes) }.freeze]
+          end.freeze
         end
 
         private
@@ -87,29 +106,71 @@ module Rigor
           when Prism::DefNode
             collect_def_writes(node, qualified_prefix)
             return
+          when Prism::CallNode
+            record_macro_call(node, qualified_prefix)
           end
 
           node.rigor_each_child { |child| walk(child, qualified_prefix) }
         end
 
+        # A receiverless (or `self.`) call in a class body, with the method names its literal Symbol / String
+        # arguments spell. Kept for every such call: which macro names count is the registry's answer, read
+        # once per class when the writes are finalised.
+        def record_macro_call(call_node, qualified_prefix)
+          return if qualified_prefix.empty?
+          return unless call_node.receiver.nil? || call_node.receiver.is_a?(Prism::SelfNode)
+
+          names = (call_node.arguments&.arguments || []).filter_map { |argument| literal_method_name(argument) }
+          return if names.empty?
+
+          ((@macro_arguments[qualified_prefix.join("::")] ||= {})[call_node.name] ||= []).concat(names)
+        end
+
+        # A Symbol / String literal's name, or the name of a `def` passed inline (`helper_method def
+        # current_user … end`). A literal with bytes no Symbol can hold (`before_action "\xff"`, #1821) names no
+        # method, so it answers nil.
+        def literal_method_name(argument)
+          return argument.name if argument.is_a?(Prism::DefNode) && argument.receiver.nil?
+          return nil unless argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+
+          text = argument.unescaped
+          text.valid_encoding? ? text.to_sym : nil
+        end
+
+        # Each write with `action` set (see {#initialize}). A frozen copy, so `#results` stays repeatable.
+        def with_actions(class_name, writes)
+          macros = @per_invocation[class_name]
+          excluded = macros ? non_action_names(class_name, macros) : nil
+          writes.map do |write|
+            action = !excluded.nil? && write[:visibility] == :public && !excluded.include?(write[:method_name])
+            write.merge(action: action).freeze
+          end.freeze
+        end
+
+        def non_action_names(class_name, macros)
+          (@macro_arguments[class_name] || {}).each_with_object(Set.new) do |(macro, names), set|
+            set.merge(names) if macros.include?(macro)
+          end
+        end
+
         def collect_def_writes(def_node, qualified_prefix)
           return if def_node.body.nil? || qualified_prefix.empty?
           return if def_node.receiver.is_a?(Prism::SelfNode)
 
           class_name = qualified_prefix.join("::")
-          gather_writes(def_node.body, class_name)
+          gather_writes(def_node.body, class_name, def_node.name)
         end
 
-        def gather_writes(node, class_name)
+        def gather_writes(node, class_name, method_name)
           return unless node.is_a?(Prism::Node)
 
-          record_write(node, class_name) if node.is_a?(Prism::InstanceVariableWriteNode)
+          record_write(node, class_name, method_name) if node.is_a?(Prism::InstanceVariableWriteNode)
           return if BARRIER_NODES.any? { |klass| node.is_a?(klass) }
 
-          node.rigor_each_child { |child| gather_writes(child, class_name) }
+          node.rigor_each_child { |child| gather_writes(child, class_name, method_name) }
         end
 
-        def record_write(node, class_name)
+        def record_write(node, class_name, method_name)
           scope = @scope_index[node]
           return if scope.nil?
 
@@ -117,7 +178,73 @@ module Rigor
           declared = declared_ivar(scope, class_name, node.name)
           @accumulator[class_name] ||= {}
           @accumulator[class_name][node.name] ||= []
-          @accumulator[class_name][node.name] << { node: node, type: rvalue_type, declared: declared }
+          @accumulator[class_name][node.name] << {
+            node: node, type: rvalue_type, declared: declared, method_name: method_name,
+            visibility: method_visibility(scope, class_name, method_name),
+            per_invocation: !per_invocation_macros(scope, class_name).nil?
+          }
+        end
+
+        # The enclosing `def`'s instance visibility, or nil when it is not a settled fact: a slot the
+        # discovery table does not hold, or one a later `define_method` / alias / unplaceable write contests
+        # (#2013). `initialize` and the other lifecycle hooks are private whatever the table says.
+        def method_visibility(scope, class_name, method_name)
+          return :private if CheckRules::IMPLICITLY_PRIVATE_METHODS.include?(method_name)
+          return nil if scope.discovery.contested?(:discovered_method_visibilities, [class_name, method_name])
+
+          scope.discovered_method_visibility(class_name, method_name)
+        end
+
+        # ADR-125 — when `class_name` is, or descends from, a class a loaded plugin declares per-invocation, the
+        # non-action macros its declaring manifests list (a Set, possibly empty); nil otherwise. Read off the
+        # class's instance {Scope::ResolutionChain}, so a project superclass chain
+        # (`UsersController < ApplicationController < ActionController::Base`) is followed as Ruby resolves it.
+        # A project entry matches by name. An external superclass matches through the first of its candidate
+        # spellings the environment knows, by name or by an RBS-known `:equal` / `:subclass` ordering. When the
+        # environment knows none of them (rigor-actionpack leaves `ActionController::Base` undeclared on
+        # purpose), a candidate that is literally a declared name matches, unless some candidate names a class
+        # the project itself declares: then the spelling may resolve there instead. An ambiguous spelling (no
+        # candidates) and a truncated chain answer nil: the carve-out only ever withholds a finding, so an
+        # unproved descent keeps the rule firing. Memoised per class.
+        def per_invocation_macros(scope, class_name)
+          return @per_invocation[class_name] if @per_invocation.key?(class_name)
+
+          @per_invocation[class_name] = matched_per_invocation_macros(scope, class_name)
+        end
+
+        def matched_per_invocation_macros(scope, class_name)
+          environment = scope.environment
+          registry = environment&.plugin_registry
+          return nil if registry.nil? || registry.per_invocation_classes.empty?
+
+          chain = Scope::ResolutionChain.for(scope, class_name, :instance, :methods)
+          return nil if chain.truncated?
+
+          declared = chain.search(scope) { |entry| matched_declarations(entry, registry, scope) }
+          declared&.each_with_object(Set.new) { |name, set| set.merge(registry.per_invocation_non_action_macros(name)) }
+        end
+
+        # The declared per-invocation names `entry` matches, or nil (so {ResolutionChain#search} moves on).
+        def matched_declarations(entry, registry, scope)
+          return (registry.per_invocation_class?(entry.name.to_s) ? [entry.name.to_s] : nil) unless entry.external?
+          return nil unless entry.superclass_edge
+
+          environment = scope.environment
+          names = entry.candidates.map { |name| name.to_s.delete_prefix("::") }
+          known = names.find { |name| environment.class_known?(name) }
+          return literal_declarations(names, registry, scope) if known.nil?
+
+          matched = registry.per_invocation_classes.select do |declared|
+            %i[equal subclass].include?(environment.class_ordering(known, declared))
+          end
+          matched.empty? ? nil : matched
+        end
+
+        def literal_declarations(names, registry, scope)
+          return nil if names.any? { |name| scope.discovered_classes.key?(name) }
+
+          matched = names.select { |name| registry.per_invocation_class?(name) }
+          matched.empty? ? nil : matched
         end
 
         def declared_ivar(scope, class_name, ivar_name)

data/lib/rigor/analysis/check_rules/lexical_method_sites.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../../inference/scope_indexer"
 require_relative "../../source/node_children"
+require_relative "rebinding_block_callees"
 
 module Rigor
   module Analysis
@@ -41,6 +42,9 @@ module Rigor
 
         def refinements = (@refinements ||= Inference::InEffectRefinements.new(@root))
 
+        # Issue #1817 — the file's block-passing calls, for `call.unresolved-toplevel`'s rebinding-callee decline.
+        def block_calls = (@block_calls ||= RebindingBlockCallees::Sites.new(@root))
+
         # Does a `def <local>.<name>` for this call's local receiver and method name — or a call that gives the
         # local's object methods Rigor does not enumerate (issue #1722) — sit in the scope the call is in?
         def singleton_local_def?(call_node)

data/lib/rigor/analysis/check_rules/rbs_receiver_surface.rb

@@ -3,6 +3,7 @@
 require_relative "../../reflection"
 require_relative "../dependency_recorder"
 require_relative "../../inference/singleton_hook_decline"
+require_relative "../../inference/object_mixins"
 
 module Rigor
   module Analysis
@@ -68,6 +69,43 @@ module Rigor
           end
         end
 
+        # Issue #2094 — the singleton side's twin of {.ancestor_may_answer?}: a module the class or an RBS superclass
+        # `extend`s (in its body, as `Float.extend(Ext)`, or as `Float.singleton_class.include(Ext)`) may answer
+        # `method_name` on the class object, read as {.mixin_defines?} / {.external_may_answer?} read an instance-side
+        # mixin. Only each level's own singleton segment is read: the class's further singleton ancestors are the
+        # RBS superclasses this walk visits in turn, and `Class` / `Module` are {.singleton_hook?}'s.
+        def singleton_mixin_may_answer?(scope, class_name, method_name)
+          singleton_class_names(scope, class_name).any? do |name|
+            DependencyRecorder.read_last_segment(:class, name) if DependencyRecorder.active?
+
+            extends_answer?(scope, name, method_name, open_mixins: !OBJECT_ROOTS.include?(name))
+          end
+        end
+
+        def singleton_class_names(scope, class_name)
+          loader = scope.environment&.rbs_loader
+          pairs = loader ? loader.singleton_ancestors_for(class_name.to_s) : []
+          names = pairs.filter_map { |kind, name| name if kind == :singleton }
+          names.empty? ? [class_name.to_s] : names
+        end
+
+        def extends_answer?(scope, name, method_name, open_mixins:)
+          chain = Scope::ResolutionChain.for(scope, name, :singleton, :methods)
+          return true if chain.truncated?
+          # A mixin call the indexer could not record (`Integer.extend(m)`, `Symbol.singleton_class.send(:include,
+          # M)`) leaves the side tainted: some module the tables do not name may answer any name.
+          return true if open_mixins && chain.wildcard_mixin?
+
+          entries = chain.level_count.zero? ? chain.entries : chain.level_entries(0)
+          entries.any? do |entry|
+            if entry.external?
+              external_may_answer?(scope, entry, method_name, open_mixins)
+            else
+              entry.name != name && mixin_defines?(scope, entry, method_name, open_mixins)
+            end
+          end
+        end
+
         # Whether a project subclass of `class_name`, at any depth, defines `method_name` (through its own
         # ancestry, which reaches its project mixins) or a `method_missing`. Its parent is read as written and
         # resolved the way the class header resolves it: the first project class the spelling can denote, else the
@@ -132,19 +170,44 @@ module Rigor
           if Rigor::Reflection.rbs_class_known?(owner, scope: scope)
             scope.discovered_method?(owner, method_name, :instance)
           else
-            project_defines?(scope, owner, method_name) ||
-              (open_mixins && Inference::SingletonHookDecline.entry_hook_capable?(scope, entry))
+            project_defines?(scope, owner, method_name) || macro_names?(scope, owner, method_name) ||
+              (open_mixins && (Inference::SingletonHookDecline.entry_hook_capable?(scope, entry) ||
+                               open_extend?(scope, owner)))
           end
         end
 
+        # Issue #2094 — a class-body macro of the module names the method ({Inference::ObjectMixins.macro_named?}).
+        # Answers the named method only, so it holds on `Object`, `Kernel` and `BasicObject` too, where a module
+        # that defines the name answers.
+        def macro_names?(scope, owner, method_name)
+          Inference::ObjectMixins.macro_named?(scope, owner, method_name)
+        end
+
+        # Issue #2094 — the module `extend`s a module whose surface is open: one neither RBS nor the project declares
+        # (a gem's DSL with no signatures), or a project module {Inference::SingletonHookDecline} reads as
+        # hook-capable. Any macro the module's body calls may come from it and define any name, and its `extended`
+        # hook may too, so the module answers any name, the reading an undeclared `include` already gets. A chain cut
+        # at its budget may hold such a module past the cut.
+        def open_extend?(scope, owner)
+          chain = Scope::ResolutionChain.for(scope, owner, :singleton, :methods)
+          return true if chain.truncated?
+
+          entries = chain.level_count.zero? ? chain.entries : chain.level_entries(0)
+          entries.any? { |extended| Inference::SingletonHookDecline.entry_hook_capable?(scope, extended) }
+        end
+
         # An external the project declares (a module with no `def`, which the chain does not hold as a project entry)
-        # is known, and answers only through RBS.
+        # is known, and answers through RBS, or through what its own body's macros and `extend`s may define (issue
+        # #2094: {.macro_names?} and {.open_extend?}, asked of each candidate the project declares).
         def external_may_answer?(scope, entry, method_name, open_mixins)
           candidates = entry.candidates
           return open_mixins if candidates.empty?
           return true if candidates.any? do |candidate|
             Rigor::Reflection.instance_method_definition(candidate, method_name, scope: scope)
           end
+          return true if candidates.any? do |candidate|
+            macro_names?(scope, candidate, method_name) || (open_mixins && open_extend?(scope, candidate))
+          end
 
           open_mixins && candidates.none? { |candidate| declared?(scope, candidate) }
         end

data/lib/rigor/analysis/check_rules/rebinding_block_callees/dispatch.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      module RebindingBlockCallees
+        # Which method a block call reaches, and on what receiver: `callee_may_rebind?` reads the callee name, a
+        # callable receiver, and whether Ruby can reach `method_missing` from here.
+        module Dispatch
+          # Issue #2186 — a block given to `call` / `bind_call` (or `yield` / `===` / `[]`) on a literal `method(:x)`
+          # chain goes to the method it names: `Ext.method(:me).call { … }` is `Ext.me { … }`. On a receiver typed as
+          # one of CALLABLE_CLASSES it goes to a callable Rigor cannot follow; on any other receiver it is a call by
+          # that name.
+          METHOD_OBJECT_CALLS = %i[call yield === [] bind_call].freeze
+          METHOD_READERS = %i[method public_method singleton_method instance_method public_instance_method].freeze
+          # The readers whose receiver is the object the named method runs on.
+          BOUND_METHOD_READERS = %i[method public_method singleton_method].freeze
+          METHOD_WRAPPERS = %i[bind unbind to_proc curry].freeze
+          CALLABLE_CLASSES = %w[Method UnboundMethod Proc].freeze
+          private_constant :METHOD_READERS, :BOUND_METHOD_READERS, :METHOD_WRAPPERS, :CALLABLE_CLASSES
+
+          module_function
+
+          # `[name, receiver]` of the method the block reaches: the call's own name, the literal name a `send` family
+          # call dispatches to, or the method a literal `method(:name)` chain names. The receiver is a node, `:implicit`
+          # for a receiverless call, or nil where Rigor cannot say (an `instance_method` chain). The name is nil when a
+          # `send` names its method with anything but a valid literal.
+          def dispatch(call)
+            reader = method_reader(call.receiver) if METHOD_OBJECT_CALLS.include?(call.name)
+            if reader
+              receiver = reader.receiver || :implicit if BOUND_METHOD_READERS.include?(reader.name)
+              return [RebindingBlockCallees.literal_name(reader.arguments&.arguments&.first), receiver]
+            end
+            [RebindingBlockCallees.send_target(call), call.receiver || :implicit]
+          end
+
+          def method_reader(receiver)
+            receiver = receiver.receiver while wrapper?(receiver)
+            receiver if receiver.is_a?(Prism::CallNode) && METHOD_READERS.include?(receiver.name)
+          end
+
+          # Whether `receiver` may be a Method, UnboundMethod or Proc, whose `call` runs a callable Rigor cannot follow.
+          def callable?(receiver, scope, scope_index)
+            return false unless receiver.is_a?(Prism::Node)
+
+            type = receiver_type(receiver, scope, scope_index)
+            members = type.is_a?(Type::Union) ? type.members : [type]
+            members.any? do |member|
+              member.is_a?(Type::BoundMethod) ||
+                (member.is_a?(Type::Nominal) && CALLABLE_CLASSES.include?(member.class_name.to_s))
+            end
+          end
+
+          def wrapper?(node) = node.is_a?(Prism::CallNode) && METHOD_WRAPPERS.include?(node.name)
+
+          # A `call` (or the like) on a receiver that may be a Method, UnboundMethod or Proc.
+          def callable_call?(name, receiver, scope, scope_index)
+            METHOD_OBJECT_CALLS.include?(name) && callable?(receiver, scope, scope_index)
+          end
+
+          def receiver_type(receiver, scope, scope_index)
+            (scope_index&.[](receiver) || scope).type_of(receiver)
+          rescue StandardError
+            nil
+          end
+
+          # Whether the receiver's type names a class whose RBS or project table gives it `name`, on every member of a
+          # union. A receiverless call at the top level asks `Object`, `main`'s class. Any other type cannot say.
+          def resolves_on_receiver?(receiver, name, scope, scope_index)
+            return scope.toplevel? && class_defines?("Object", :instance, name, scope) if receiver == :implicit
+            return false if receiver.nil?
+
+            type = receiver_type(receiver, scope, scope_index)
+            !type.nil? && type_resolves?(type, name, scope)
+          rescue StandardError
+            false
+          end
+
+          def type_resolves?(type, name, scope)
+            case type
+            when Type::Union then type.members.all? { |member| type_resolves?(member, name, scope) }
+            when Type::Singleton then class_defines?(type.class_name, :singleton, name, scope)
+            else
+              class_name = receiver_class_name(type)
+              !class_name.nil? && class_defines?(class_name, :instance, name, scope)
+            end
+          end
+
+          def receiver_class_name(type)
+            case type
+            when Type::Nominal, Type::StructInstance, Type::DataInstance then type.class_name&.to_s
+            when Type::Tuple then "Array"
+            when Type::HashShape then "Hash"
+            when Type::Constant then type.value.class.name
+            end
+          end
+
+          def class_defines?(class_name, side, name, scope)
+            rbs = if side == :singleton
+                    Rigor::Reflection.singleton_method_definition(class_name, name, scope: scope)
+                  else
+                    Rigor::Reflection.instance_method_definition(class_name, name, scope: scope)
+                  end
+            !rbs.nil? || scope.discovered_method?(class_name, name, side)
+          end
+        end
+      end
+    end
+  end
+end