rigortype 0.4.6 → 0.4.8

data/lib/rigor/scope/discovery_index.rb

@@ -60,7 +60,14 @@ module Rigor
       :contested_discovered_parameter_envelopes
     )
 
-    class DiscoveryIndex
+    class DiscoveryIndex # rubocop:disable Metrics/ClassLength -- the envelope kinds and marks are one constant each
+      # Issue #2330 — identity as a hash key. `Data` hashes and compares structurally, which over these project-sized
+      # tables is both costly and wrong for a per-thread memo keyed by "this very index" (an `ObjectSpace::WeakKeyMap`
+      # holds the memo while the index lives and drops it with it). `==` stays structural.
+      def hash = object_id.hash
+
+      def eql?(other) = equal?(other)
+
       EMPTY_NODE_TABLE = {}.compare_by_identity.freeze
       EMPTY_TABLE = {}.freeze
       EMPTY_NAME_SET = Set.new.freeze
@@ -240,6 +247,100 @@ module Rigor
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"
       ENVELOPE_REFINED_MARK = :"<refined>"
+      # Issue #2793 — a class-body macro defines methods under names its syntax does not spell
+      # (`def_delegators :@x, *NAMES`), so no table can enumerate the class's members: `call.undefined-method`
+      # treats the class, and every project class that inherits or mixes it in, as open, as it does a source
+      # `method_missing`. Not a {.rewritten_surface?} mark: the macro adds names and replaces no method body
+      # Rigor reads.
+      ENVELOPE_OPEN_NAMES_MARK = :"<open-names>"
+      # Issue #2793 — the sided twins of {ENVELOPE_OPEN_NAMES_MARK}: a `define_method` whose name is not a literal
+      # (`%i[a b].each { |m| define_method(m) { } }`) where `self` is the class defines instance methods no table can
+      # name, and one in a `class << self` body singleton methods. `call.undefined-method` reads the instance mark
+      # for an instance receiver and the singleton mark for the class object, each beside the sideless mark.
+      ENVELOPE_OPEN_INSTANCE_NAMES_MARK = :"<open-instance-names>"
+      ENVELOPE_OPEN_SINGLETON_NAMES_MARK = :"<open-singleton-names>"
+      # Issue #2901 — the two halves of a class macro that defines methods under computed names. A
+      # `[ENVELOPE_COMPUTED_DEFINER_KIND, side, name]` entry says the class or module's own method `name`, on `side`
+      # (`:singleton` or `:instance`, #2975), runs a `define_method` on its `self` whose name is not a literal
+      # (`def self.my_attr(*n) = n.each { |x| define_method(x) {} }`, or a module's instance method an `extend` makes a
+      # class macro). A
+      # `[ENVELOPE_BODY_CALL_KIND, name]` entry says the class body calls `name` on `self` (`my_attr :foo`).
+      # `call.undefined-method` reads a class as instance-open when a body call of it resolves, on its singleton
+      # chain, to a computed definer. Neither entry names a member, so neither declares a surface.
+      ENVELOPE_COMPUTED_DEFINER_KIND = :computed_definer
+      ENVELOPE_BODY_CALL_KIND = :body_call
+      # Issue #2975 — `[ENVELOPE_HOOK_EXTEND_KIND, "ClassMethods"]` says the module's `self.included(base)` (or
+      # `self.prepended(base)`) hook runs `base.extend(ClassMethods)`, the constant as written: an includer's
+      # singleton chain then reaches `ClassMethods`, whose computed definers its body calls may resolve to.
+      #
+      # Issue #2986 — an `extend ActiveSupport::Concern` module records `[ENVELOPE_HOOK_EXTEND_KIND, "ClassMethods",
+      # :const_get]`: `Concern#append_features` extends its includer with `const_get(:ClassMethods)`, which searches the
+      # module, its ancestors and `Object`, not the lexical scope. A `[ENVELOPE_HOOK_BODY_CALL_KIND, hook, name]` entry
+      # says its `included do … end` (`hook` `:included`) or `prepended do … end` (`:prepended`) block calls `name` on
+      # `self`, which Ruby runs in the class body of a class that includes (or prepends) the module directly. It is
+      # filed only on the module whose body the walk is in, so it is not one of `Incremental`'s diffed class-mark kinds.
+      #
+      # Issue #1592 — a hook's own entry names the hook as its third element (`[ENVELOPE_HOOK_EXTEND_KIND, "M",
+      # :included]`, `:prepended` for `self.prepended` or a `prepended do … end` block), and an `extend` on `self` in a
+      # concern's `included do … end` / `prepended do … end` block records one too. The includer's singleton resolution
+      # chain inserts each such module for the edge its hook runs on. A `[ENVELOPE_HOOK_EXTEND_OPEN_KIND, hook]` entry
+      # says that hook may extend its includer with a module no entry names, or one it may not extend at all (an
+      # `extend` that is not a direct statement of the hook body, or whose argument is not a constant).
+      ENVELOPE_HOOK_EXTEND_KIND = :hook_extend
+      ENVELOPE_HOOK_EXTEND_OPEN_KIND = :hook_extend_open
+      # Issue #1592 — `[ENVELOPE_HOOK_DEF_KIND, hook, source]`: one definition of the module's `self.included` /
+      # `self.prepended` hook, by its source text. Two entries for one hook mean the hook is defined twice, and which
+      # definition Ruby keeps is load order.
+      ENVELOPE_HOOK_DEF_KIND = :hook_def
+      ENVELOPE_HOOK_BODY_CALL_KIND = :hook_body_call
+      # Issue #2992 — `[ENVELOPE_CONCERN_DEPENDENCY_KIND, "Dep"]`: the module's body runs `include Dep` (or `prepend
+      # Dep`) after its own `extend ActiveSupport::Concern`, so a concern `Dep` is a dependency of the module, which
+      # ActiveSupport includes into the module's final includer instead. Filed only on the module whose body the walk
+      # is in, as the hook-body-call entry is.
+      ENVELOPE_CONCERN_DEPENDENCY_KIND = :concern_dependency
+      # Issue #3005 — the hook a hook-extend, open or hook-body-call entry names when it comes from an `included do …
+      # end` / `prepended do … end` block in a body that does not run `extend ActiveSupport::Concern` itself. The
+      # block is ActiveSupport's only when some body of the module records the concern entry; a reader takes the
+      # gated hook as the plain one then, and as no hook otherwise ({ResolutionChain.effective_hook}).
+      CONCERN_BLOCK_HOOKS = { included: :concern_included, prepended: :concern_prepended }.freeze
+      # Issue #3005 — the last segment of the module a concern block's `def self.x`s are filed on (`Owner::<included>`),
+      # and the spelling its hook-extend entry names.
+      HOOK_BLOCK_SEGMENTS = %w[<included> <prepended>].freeze
+      # Issue #2979 — `[ENVELOPE_SAME_CLASS_KIND, "Struct::Named"]` on `K`'s bucket, and its mirror on
+      # `Struct::Named`'s, say that `K = Struct.new("Named", …)` binds both constants to one class object: the method
+      # chain of either name reads the other's tables at its own position ({.same_class_names}). It names no member.
+      ENVELOPE_SAME_CLASS_KIND = :same_class
+      # Issue #2998 — `[ENVELOPE_SINGLETON_PREPEND_KIND, "P"]` on `K`'s bucket says one of `K`'s `discovered_extends`
+      # entries spelt `"P"` is a prepend to `K`'s singleton class (`class << self; prepend P; end`,
+      # `singleton_class.prepend P`, `singleton_class.send(:prepend, P)` in `K`'s body), which sits ahead of the class
+      # object's own methods where an `extend` sits behind them. The singleton resolution chain reads it.
+      ENVELOPE_SINGLETON_PREPEND_KIND = :singleton_prepend
+      # Issue #3018 — `[ENVELOPE_OBJECT_SINGLETON_KIND, name]` says a definer written on the constant's object from
+      # outside its body defines `name` there: `def K.name`, a literal `K.define_singleton_method(:name)`, or a `def
+      # name` in a `K.singleton_class.class_eval` block. Each also files the opaque `[:singleton, name]` entry, which
+      # name-rewriting class-body macros (`memoize :name`) file too; this entry is the one the class-object path of
+      # `call.undefined-method` reads as evidence the singleton method exists.
+      ENVELOPE_OBJECT_SINGLETON_KIND = :object_singleton
+      MACRO_KINDS = [ENVELOPE_BODY_CALL_KIND, ENVELOPE_COMPUTED_DEFINER_KIND, ENVELOPE_HOOK_EXTEND_KIND,
+                     ENVELOPE_HOOK_EXTEND_OPEN_KIND, ENVELOPE_HOOK_DEF_KIND, ENVELOPE_HOOK_BODY_CALL_KIND,
+                     ENVELOPE_CONCERN_DEPENDENCY_KIND, ENVELOPE_SAME_CLASS_KIND,
+                     ENVELOPE_SINGLETON_PREPEND_KIND].freeze
+      private_constant :MACRO_KINDS
+
+      NO_NAMES = [].freeze
+      private_constant :NO_NAMES
+
+      # Issue #2979 — the other names an envelope bucket says its class object is bound to
+      # ({ENVELOPE_SAME_CLASS_KIND}), in recording order; empty for nearly every bucket, and allocates nothing then.
+      def self.same_class_names(bucket)
+        return NO_NAMES if bucket.nil?
+
+        names = nil
+        bucket.each_key do |key|
+          (names ||= []) << key.last if key.is_a?(Array) && key.first == ENVELOPE_SAME_CLASS_KIND
+        end
+        names || NO_NAMES
+      end
 
       # Issue #1820 — whether an envelope bucket says the project declares, or rewrites, the name's method table: a
       # per-method entry, the {ENVELOPE_MODULE_MARK} a `module` declaration records, or the {ENVELOPE_DYNAMIC_MARK}
@@ -251,7 +352,60 @@ module Rigor
       private_constant :DECLARING_MARKS
 
       def self.declares_surface?(bucket)
-        !bucket.nil? && bucket.any? { |key, _| !key.is_a?(Symbol) || DECLARING_MARKS.include?(key) }
+        !bucket.nil? && bucket.any? { |key, _| declaring_key?(key) }
+      end
+
+      # Issue #2901 — a per-method entry declares a member; the two macro entries ({ENVELOPE_BODY_CALL_KIND},
+      # {ENVELOPE_COMPUTED_DEFINER_KIND}) do not.
+      def self.declaring_key?(key)
+        return DECLARING_MARKS.include?(key) if key.is_a?(Symbol)
+
+        !(key.is_a?(Array) && MACRO_KINDS.include?(key.first))
+      end
+
+      # Issue #2968 — the open-names marks of one side: {ENVELOPE_OPEN_NAMES_MARK} and the side's own twin.
+      OPEN_NAMES_MARKS = {
+        instance: [ENVELOPE_OPEN_NAMES_MARK, ENVELOPE_OPEN_INSTANCE_NAMES_MARK].freeze,
+        singleton: [ENVELOPE_OPEN_NAMES_MARK, ENVELOPE_OPEN_SINGLETON_NAMES_MARK].freeze
+      }.freeze
+      private_constant :OPEN_NAMES_MARKS
+
+      # Issue #2968 — whether an entry of `class_name`'s `kind` chain carries that side's open-names mark: a splatted
+      # `Struct.new(*FIELDS)`, `attr_accessor(*NAMES)`, a `define_method` under a computed name, so the side defines
+      # methods no table names. A project class with no `def` of its own is an external entry (#2094), so its candidate
+      # names are asked too. Read by `Reflection.project_method_defined` and by the implicit-self top-level-`def` veto
+      # (`ExpressionTyper#instance_self_answers?`), beside `call.undefined-method`'s own reader.
+      def self.open_names_on_chain?(scope, class_name, kind)
+        marks = OPEN_NAMES_MARKS.fetch(kind)
+        chain = ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+        found = chain.search(scope) do |entry|
+          names = entry.external? ? entry.candidates : [entry.name]
+          names.any? do |name|
+            bucket = scope.parameter_envelopes_of(name)
+            marks.any? { |mark| bucket.key?(mark) }
+          end
+        end
+        !found.nil?
+      end
+
+      # Issue #2994 — whether `class_name`'s instance-side chain mixes in a module no table names
+      # (`ResolutionChain#unnamed_mixin?`: `include(*MODS)`, `include helper`, a hook's `base.include`). A project class
+      # with no `def` of its own is an external entry (#2094) whose ancestry the chain does not walk, so each of its
+      # candidate names that the project declares is asked on its own chain. Read beside {.open_names_on_chain?} by
+      # `Reflection.project_method_defined` and by the implicit-self top-level-`def` veto.
+      def self.unnamed_mixin_on_chain?(scope, class_name)
+        chain = ResolutionChain.for(scope, class_name.to_s, :instance, :methods)
+        return true if chain.unnamed_mixin?
+
+        found = chain.search(scope) do |entry|
+          next false unless entry.external?
+
+          entry.candidates.any? do |name|
+            scope.discovered_classes.key?(name) &&
+              ResolutionChain.for(scope, name, :instance, :methods).unnamed_mixin?
+          end
+        end
+        !found.nil?
       end
 
       # Whether an envelope bucket says the project rewrites the class's method table beyond its literal names: a
@@ -423,10 +577,9 @@ module Rigor
         struct_member_layouts: EMPTY_TABLE,
         # ADR-67 WD3 — the call-site parameter-inference table, keyed by `[class_name, method_name, kind]` (the
         # same `(class, method, kind)` triple {Inference::ParameterInferenceCollector} records and that
-        # `build_method_entry_scope` reconstructs from the lexical class path). The value is a
-        # `{param_name(Symbol) => Rigor::Type}` map of the union of resolved call-site argument types. Empty on
-        # every normal run; only the `coverage --protection` collection pass populates it today, so a `check` run
-        # leaves it empty and seeds nothing (byte-identical).
+        # `build_method_entry_scope` reconstructs from the lexical class path). The value is the
+        # union of resolved call-site argument types per parameter name. Empty unless `parameter_inference:` is
+        # on or the `coverage --protection` collection pass runs; a run with neither seeds nothing (byte-identical).
         param_inferred_types: EMPTY_TABLE,
         # ADR-84 WD2 — the run-scope identity token `Analysis::Runner#run_analysis` mints per run (a frozen
         # bare Object) and seeds through `project_scope_seed_tables`. The user-method return memo keys its
@@ -474,7 +627,6 @@ module Rigor
       # possible fact carries, and a Runner's initial state. Copy it (`dup`) before mutating.
       EMPTY_SIBLINGS = SIBLINGS.each_value.to_h { |sibling| [sibling, EMPTY.public_send(sibling)] }.freeze
 
-      # The all-empty value of a paired member or sibling.
       def self.empty_value(name)
         EMPTY.public_send(name)
       end
@@ -499,7 +651,6 @@ module Rigor
         end
       end
 
-      # Whether `name` is a member or sibling of {SIBLINGS}.
       def self.paired?(name)
         PARTNERS.key?(name)
       end
@@ -522,6 +673,15 @@ module Rigor
         recorded == kind || (!recorded.nil? && recorded == METHOD_KIND_BOTH)
       end
 
+      # Issue #681 / #707 — the `Module.nesting` the declaration walk recorded for `def_node`, or nil when it recorded
+      # none: {#discovered_def_nestings} first, then its rehydration for a def served from an ADR-85 seed bundle, whose
+      # node {Inference::DefNodeResolver} mints from its own parse ({Inference::DefNodeResolver.rehydrated_nesting}).
+      # The one reader of the table outside its owners; `ExpressionTyper#recorded_def_nesting` says why the order is
+      # safe.
+      def recorded_def_nesting(def_node)
+        discovered_def_nestings[def_node] || Inference::DefNodeResolver.rehydrated_nesting(def_node)
+      end
+
       # ADR-119 WD1 — whether `path` (`[class, name]`, or `[class, [kind, name]]` for an envelope) is a contested
       # entry of `member`, one of the single-valued members {SIBLINGS} pairs. Internal to the candidate-set read.
       def contested?(member, path)

data/lib/rigor/scope/resolution_chain/relevance.rb

@@ -27,6 +27,8 @@ module Rigor
       # segment of its spelling, so a new file declaring the module re-checks the consumer.
       module Relevance
         WILDCARD = "*"
+        # Issue #2991 — listed beside {WILDCARD} when the side mixes in a module no name spells.
+        UNNAMED = "?"
 
         # The singleton hooks Ruby calls while a module enters (or is asked to enter) another's ancestry. A module
         # that defines one can add methods to the includer, extender or prepender with nothing the tables record
@@ -39,7 +41,18 @@ module Rigor
         def discharged?(scope, chain, mark, name)
           name = name.to_sym
           memo = ResolutionChain.relevance_memo(scope, chain.flavor)
-          verdict, edges = memo[[mark, name]] ||= compute(scope, chain.flavor, mark, name)
+          key = [mark, name]
+          entry = memo[key]
+          verdict, edges =
+            if entry.nil?
+              memo[key] = Inference::MemoAudit.key_audit("resolution chain relevance") do
+                compute(scope, chain.flavor, mark, name)
+              end
+            else
+              Inference::MemoAudit.check("resolution chain relevance", entry, mark, name) do
+                Analysis::DependencyRecorder.withhold { compute(scope, chain.flavor, mark, name) }.first
+              end
+            end
           replay(scope, edges) if Analysis::DependencyRecorder.active?
           verdict
         end