rigortype 0.4.1 → 0.4.3

data/lib/rigor/scope/discovery_index.rb

@@ -51,6 +51,7 @@ module Rigor
       :clears_last_status,
       :defines_case_equality,
       :implicit_self_evidence,
+      :in_effect_refinements,
       :possible_discovered_methods,
       :possible_discovered_deferred_ranges,
       :contested_discovered_def_nodes,
@@ -155,6 +156,7 @@ module Rigor
           patched_line_readers: "the gets / readline names the file defines through the define_method family",
           clears_last_status: "whether the analysed file holds a call that may set $? to nil",
           defines_case_equality: "whether the analysed file holds a define_method naming ===",
+          in_effect_refinements: "the file's ordered in-effect refinements; built lazily from its tree, never seeded",
           implicit_self_evidence: "where the file's implicit-self readers sit; built lazily from its tree, never seeded"
         }.freeze,
         run_state: {
@@ -217,12 +219,36 @@ module Rigor
       # - {ENVELOPE_REFINED_MARK}: a `refine` block refines the class, which redefines its methods wherever a `using`
       #   is in effect. Issue #1367 splits it from {ENVELOPE_DYNAMIC_MARK}, which it used to share: an implicit
       #   conversion (`to_str`, `to_int`) ignores a refinement, so the `global.*` rules must tell the two apart.
-      #   Every reader that asks whether a surface is rewritten reads both ({.rewritten_surface?}).
+      #   The readers that ask whether a surface is rewritten read both ({.rewritten_surface?}), except
+      #   `call.wrong-arity`'s source envelope (`CheckRules::SourceArity`), which leaves a refinement to the per-call
+      #   decline that knows the name and the `using` (issue #1797).
+      # Issue #1820 — the kind of a `[ENVELOPE_REMOVED_KIND, method_name]` bucket entry: the project removes the name
+      # from the class with a literal `undef`, `remove_method` or `undef_method`, whichever side. A removal is not
+      # otherwise distinguishable from an `attr_*` or `define_method`, whose envelope is opaque too, and the
+      # refinement own-definer proof must not take a removed method as the one Ruby finds.
+      ENVELOPE_REMOVED_KIND = :removed
+      # Issue #1820 — a `K = Class.new(Parent)` constant write: the class's superclass is not in the superclass table
+      # (the meta-new walk does not route `Parent` through ancestor discovery), so a reader that must place `K` in a
+      # hierarchy reads its superclass as unknown, as it reads the `nil` the table records for `class K < <expr>`.
+      ENVELOPE_META_SUPERCLASS_MARK = :"<meta-superclass>"
       ENVELOPE_MODULE_MARK = :"<module>"
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"
       ENVELOPE_REFINED_MARK = :"<refined>"
 
+      # 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}
+      # (`Comparable.module_eval { define_method(computed) }` gives a module a method no table names, so a reader
+      # must keep it on its chain rather than read RBS's surface for it). A bucket that holds only the refined,
+      # object-extended or meta-superclass marks is evidence about a name the project may only mention, such as
+      # `Comparable` in `x.singleton_class.prepend(Comparable)`.
+      DECLARING_MARKS = [ENVELOPE_MODULE_MARK, ENVELOPE_DYNAMIC_MARK].freeze
+      private_constant :DECLARING_MARKS
+
+      def self.declares_surface?(bucket)
+        !bucket.nil? && bucket.any? { |key, _| !key.is_a?(Symbol) || DECLARING_MARKS.include?(key) }
+      end
+
       # Whether an envelope bucket says the project rewrites the class's method table beyond its literal names: a
       # dynamic rewrite, or a refinement.
       def self.rewritten_surface?(bucket)
@@ -236,6 +262,14 @@ module Rigor
       # present. Not a constant character, so no class can be named it.
       ENVELOPE_PROJECT_WIDE = "<project-wide>"
 
+      # ADR-121 WD7 (issues #1796, #1799) — the wildcard of `discovered_refinements`, standing for what the walk could
+      # not read. As a refined-class key it is a class the walk cannot name (`refine(k)`, `refine(self)`); as a method
+      # key, names a refine body defines that the walk cannot enumerate (`import_methods`, a computed
+      # `define_method`); as a refining module, a module the walk cannot name (a `refine` in an instance method,
+      # which any module extending it may run). `{"*" => {"*" => [M]}}` makes `M` opaque: some `refine` of `M` is
+      # unreadable. No constant can be named `*`, and method keys are Symbols, so neither axis collides.
+      REFINEMENT_WILDCARD = "*"
+
       # The shared all-empty index `Scope.empty` (and every scope that never sees a seeding pass) points at — one
       # allocation per process.
       EMPTY = new(
@@ -417,6 +451,11 @@ module Rigor
         # them by. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
         # indexed, declines every such reader.
         implicit_self_evidence: nil,
+        # Issue #1673 (ADR-121 WD1) — the file's in-effect refinements (`Inference::InEffectRefinements`, walked on the
+        # first ask), which `Scope#in_effect_refinements` reads for the typer and the check rules read off the root's
+        # scope. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
+        # indexed, answers no lexical refinement.
+        in_effect_refinements: nil,
         # ADR-119 WD1 — the siblings of the members {SIBLINGS} pairs, empty until a producer admits a possible fact.
         possible_discovered_methods: EMPTY_TABLE,
         possible_discovered_deferred_ranges: EMPTY_TABLE,

data/lib/rigor/scope/resolution_chain.rb

@@ -83,10 +83,12 @@ module Rigor
       # One ancestor on a chain. A project entry names a class or module (`name`) on `side` `:instance` (its
       # instance methods) or `:singleton` (the class object's singleton). An external entry has no `name`: it
       # keeps the spelling (`raw`) and its candidate names (`candidates`, most qualified first, empty for an
-      # ambiguous spelling), and `superclass_edge` says it was reached through a superclass edge.
+      # ambiguous spelling), and `superclass_edge` says it was reached through a superclass edge. `owner` names
+      # the class or module whose edge an external entry is (#1698: Ruby resolves an `include`'s argument with
+      # that body as the innermost cref, a namespace `candidates` leaves out); it is nil on a project entry.
       # `last_segment` is the unqualified name a project entry files its negative class edge under, computed once
       # when the entry is interned.
-      Entry = Data.define(:name, :side, :raw, :candidates, :superclass_edge, :last_segment) do
+      Entry = Data.define(:name, :side, :raw, :candidates, :superclass_edge, :last_segment, :owner) do
         def external? = name.nil?
       end
 
@@ -98,7 +100,9 @@ module Rigor
       # module whose mixin edges' order is not a fact, `kind` the side read (`:include` or `:extend`), `listed`
       # the entries `DiscoveryIndex#unpositioned_mixins` lists for it (`"*"` included), and `multi_file` whether
       # the multi-file rule fired (two or more files declare it and it has two or more edges on that side).
-      # Interned per `[node, kind]` in the flavor's bucket, so equal marks are one object.
+      # Interned per `[node, kind]` in the flavor's bucket, so equal marks are one object. Kind `:extend_hook`
+      # (#1730, listing `"*"`) marks a node a module it extends may mix into through a hook; it is not an order mark
+      # ({#order_marks}).
       Mark = Data.define(:node, :kind, :listed, :multi_file)
 
       NO_MARKS = [].freeze
@@ -135,7 +139,20 @@ module Rigor
 
       # True when a class on the chain has mixin edges whose order the tables cannot vouch for
       # (`DiscoveryIndex#unpositioned_mixins`, or a class declared in several files with several edges).
-      def unsettled? = !@marks.empty?
+      def unsettled? = !order_marks.empty?
+
+      # The marks that make the chain's ORDER doubtful. An `:extend_hook` mark (#1730) says only that an extended
+      # module's hook may have mixed something in that the chain does not list: it makes a candidate-set read
+      # `:unknown` and {#wildcard_mixin?} true, and leaves every other reader on the chain's own order. Sending
+      # those readers to master's order would answer a constant lookup breadth-first, which is wrong for the
+      # #1567 shape on every class that extends such a module.
+      def order_marks
+        @memo[:order_marks] ||= @marks.reject { |mark| mark.kind == :extend_hook }.freeze
+      end
+
+      # True when a class on the chain records a mixin the tables cannot name (`"*"`: an `include` of a
+      # non-constant, or a call the walk cannot record), so the chain may hold a module it does not list.
+      def wildcard_mixin? = @marks.any? { |mark| mark.listed.include?(Relevance::WILDCARD) }
 
       # The ONE decision every first-definer reader makes: does `answer`, read off this chain, stand, or does
       # the reader answer what the walk this chain replaced answered ({MasterOrder})? Returns `:chain` or
@@ -163,7 +180,7 @@ module Rigor
         # goes; `search` files only the entries ahead of an answer. `owner` names the entry that answered.
         record_beyond(scope, owner, unknown_for.nil?)
         return settle_unknown(scope, answer, unknown_for, &) unless unknown_for.nil?
-        return :master unless @marks.empty?
+        return :master unless order_marks.empty?
 
         case @forks
         when 0 then :chain
@@ -208,7 +225,10 @@ module Rigor
       def search(scope, start = 0, stop = nil, side: nil)
         recording = Analysis::DependencyRecorder.active?
         stop ||= @entries.size
-        record_head(scope, start, side) if recording
+        if recording
+          record_head(scope, start, side)
+          record_extend_hooks(scope)
+        end
         index = start
         while index < stop
           entry = @entries[index]
@@ -228,6 +248,7 @@ module Rigor
 
         ResolutionChain.record_class(scope, @root)
         (stop || @entries.size).times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
+        record_extend_hooks(scope)
       end
 
       # What a {#settle} verdict adds to what the search already filed. The search files the root and every entry
@@ -241,7 +262,8 @@ module Rigor
       #   it `:unknown`, so the rest of the chain is filed as for any other answer;
       # - otherwise every entry after the answer (the whole chain when `owner` names none) files its class edge
       #   and, for a project entry, the negative class edge on its unqualified name, so a NEW file declaring or
-      #   reopening it re-checks the reader. An external entry files only the sites of the names it can denote.
+      #   reopening it re-checks the reader. An external entry files only the sites of the names it can denote,
+      #   and every external on the chain files its hook edges ({#record_hooks}, #1641).
       #
       # What is filed is a function of this chain, the entry the filing starts from and the discovery index the
       # sites are read from, so a consumer that settles the same chain from the same entry again (the common case:
@@ -253,6 +275,8 @@ module Rigor
 
         start = owner.nil? ? nil : @entries.index { |entry| entry.name == owner }
         Analysis::DependencyRecorder.file_chain_once(self, start, scope.discovery) { file_beyond(scope, start) }
+        record_hooks(scope)
+        record_extend_hooks(scope)
       end
       private :record_beyond
 
@@ -268,6 +292,113 @@ module Rigor
       end
       private :file_beyond
 
+      # #1641 — the hook edges of every EXTERNAL entry on the chain, ahead of the answer or past it. A project file
+      # that gives an external module a hook (`module Comparable; def self.included(base) = base.prepend(P); end`)
+      # can put a definer ahead of the answer wherever the module sits, and a candidate-set read declines on it
+      # (the hook's mixin lists `"*"` on the module). The entry's class edges are the sites of the names it can
+      # denote, which a NEW file is not among, and a negative class edge on its name would re-check every reader of
+      # `Kernel` or `Enumerable` on any reopening. So each candidate name files the negative method edge of every
+      # {Relevance::HOOKS} name on its singleton side (`method:Comparable.included`, the key a new `def
+      # self.included` satisfies); a file adding any other method to the module re-checks nothing, and once the
+      # module is declared its sites carry later edits and the removal. The edges are a function of the chain alone,
+      # so a consumer files them once per chain ({Analysis::DependencyRecorder.file_chain_once}, #1590). A hook
+      # written another way — an instance `def included` in a module extended onto the external, a
+      # `define_singleton_method(:included)` — satisfies no such key and is not seen.
+      def record_hooks(scope)
+        externals = (@memo[:externals] ||= @entries.select(&:external?).freeze)
+        return if externals.empty?
+
+        Analysis::DependencyRecorder.file_chain_once(self, :hooks, scope.discovery) do
+          externals.each do |entry|
+            entry.candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.hook_keys(name)) }
+          end
+        end
+      end
+      private :record_hooks
+
+      # #1730 — the edges of the {Builder#extend_hook_taint?} decision: an instance chain's project entries may carry
+      # a `"*"` mark because a module one of them `extend`s has a hook that mixes into the extender, and the
+      # module is often declared in a file the chain records nothing of. Each such module the decision read files
+      # its class edges (an edit to its hook moves its declaration signature) and the negative method edges of
+      # the hooks the decision reads ({ResolutionChain.extend_hook_keys}), which a NEW file reopening the module
+      # to add a hook satisfies; a spelling no project module answers files the singleton hook keys of each name
+      # it can denote, as {#record_hooks} does. Filed once per consumer and chain.
+      def record_extend_hooks(scope)
+        return unless @side == :instance
+
+        targets = (@memo[:extend_targets] ||= ResolutionChain.extend_targets(scope, @flavor, @entries))
+        return if targets.empty?
+
+        Analysis::DependencyRecorder.file_chain_once(self, :extend_hooks, scope.discovery) do
+          targets.each do |raw, resolved, candidates|
+            Analysis::DependencyRecorder.read_last_segment(:class, raw)
+            if resolved
+              ResolutionChain.record_class(scope, resolved)
+              Analysis::DependencyRecorder.read_keys(ResolutionChain.extend_hook_keys(resolved))
+            else
+              candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.hook_keys(name)) }
+            end
+          end
+        end
+      end
+      private :record_extend_hooks
+
+      # The hooks that let a module `extend`ed onto N reshape N's INSTANCE side (#1730): its singleton `extended` /
+      # `extend_object` run against N at the `extend` and may mix into N; its instance `included` /
+      # `append_features` / `prepended` / `prepend_features` / `inherited` become N's own singleton hooks and run
+      # against N's includers, prependers and subclasses, which the mark on N reaches through their chains.
+      SINGLETON_EXTEND_HOOKS = %i[extended extend_object].freeze
+      INSTANCE_EXTEND_HOOKS = %i[included append_features prepended prepend_features inherited].freeze
+
+      @extend_hook_keys = {}
+
+      # The frozen negative method keys of `name`'s {SINGLETON_EXTEND_HOOKS} and {INSTANCE_EXTEND_HOOKS}.
+      def self.extend_hook_keys(name)
+        @extend_hook_keys[name] ||= (
+          SINGLETON_EXTEND_HOOKS.map { |hook| "method:#{name}.#{hook}".freeze } +
+          INSTANCE_EXTEND_HOOKS.map { |hook| "method:#{name}##{hook}".freeze }
+        ).freeze
+      end
+
+      # Whether extending `name` may mix modules into the extender's instance side, or into its includers' (#1730):
+      # `name` records a mixin it cannot name on its own instance side (`"*"`, which a hook's `base.include X` or
+      # `base.class_eval { … }` lists on the hook's module) and defines one of the hooks that would run it there.
+      def self.extend_reshapes_instance?(scope, name)
+        listed = scope.discovery.unpositioned_mixins[name]&.dig(:include)
+        return false unless listed&.include?(Relevance::WILDCARD)
+
+        defines_any?(scope.discovered_singleton_def_nodes[name], SINGLETON_EXTEND_HOOKS) ||
+          defines_any?(scope.discovered_def_nodes[name], INSTANCE_EXTEND_HOOKS)
+      end
+
+      # Read off the def-node tables: the existence table does not carry a module's own instance hook once the
+      # extend fold has copied it onto the extender's singleton.
+      def self.defines_any?(defs, hooks)
+        !defs.nil? && hooks.any? { |hook| defs.key?(hook) }
+      end
+
+      # `[[spelling, resolved name or nil, candidate names], …]`: every module the project entries of an instance chain
+      # `extend`, as {Builder#extend_hook_taint?} resolved them.
+      def self.extend_targets(scope, flavor, entries)
+        resolver = resolver_for(scope, flavor)
+        extends = scope.discovery.discovered_extends
+        entries.each_with_object([]) do |entry, out|
+          next if entry.external? || entry.side != :instance
+
+          (extends[entry.name] || EMPTY_NAMES).each do |raw|
+            resolved = resolver.resolve_one(entry.name, raw)
+            out << [raw, resolved, resolved ? EMPTY_NAMES : resolver.candidates(entry.name, raw)].freeze
+          end
+        end.uniq.freeze
+      end
+
+      @hook_keys = {}
+
+      # The frozen `method:Name.hook` negative keys of `name`'s {Relevance::HOOKS}, built once per name.
+      def self.hook_keys(name)
+        @hook_keys[name] ||= Relevance::HOOKS.map { |hook| "method:#{name}.#{hook}".freeze }.freeze
+      end
+
       def record_head(scope, start, side)
         ResolutionChain.record_class(scope, @root) unless start.zero? && @entries.first&.name == @root
         start.times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
@@ -397,7 +528,8 @@ module Rigor
             @discovery.discovered_superclasses.key?(name) || @discovery.discovered_includes.key?(name) ||
               @discovery.discovered_classes.key?(name)
           when :arity
-            @scope.known_user_class?(name) || @discovery.discovered_parameter_envelopes.key?(name)
+            @scope.known_user_class?(name) ||
+              DiscoveryIndex.declares_surface?(@discovery.discovered_parameter_envelopes[name])
           else
             @scope.known_user_class?(name)
           end
@@ -601,7 +733,8 @@ module Rigor
         # The chain for `root`, carrying its retro world when the skip rule skipped anything on the way.
         def chain(root, side)
           entries, starts, classes, forks, marks, retro_ok = lin_for(root, side)
-          retro = build_retro(root, side) if forks == 1 && retro_ok && marks.empty? && !@retro
+          order_marked = marks.any? { |mark| mark.kind != :extend_hook }
+          retro = build_retro(root, side) if forks == 1 && retro_ok && !order_marked && !@retro
           cut_at = cut_position(entries)
           return whole_chain(root, side, entries, starts, classes, [forks, marks], retro) if cut_at.nil?
 
@@ -701,6 +834,7 @@ module Rigor
         def compute_instance(name, depth)
           # `discovered_includes` already carries the prepended names, so it counts every instance-side edge once.
           mark_unsettled(name, :include, (@discovery.discovered_includes[name] || EMPTY).size)
+          @frames.last.add_marks(mark_for(name, :extend_hook, WILDCARD_LIST, false)) if extend_hook_taint?(name)
           entries = [project_entry(name, :instance)]
           super_lin = superclass_lin(name, :instance, depth)
           entries.concat(super_lin[0])
@@ -743,6 +877,20 @@ module Rigor
                                                        multi)].freeze
         end
 
+        WILDCARD_LIST = ["*"].freeze # Relevance::WILDCARD, which loads after this file
+        private_constant :WILDCARD_LIST
+
+        # #1730 — whether a module `name` extends has a hook that may mix into `name`'s instance side or its
+        # includers' ({ResolutionChain.extend_reshapes_instance?}). Ruby runs it at the `extend`, so the mixin is
+        # not a fact of the tables and `name`'s instance side is unpositioned. A spelling no project module
+        # answers taints nothing: the project cannot see its hooks.
+        def extend_hook_taint?(name)
+          (@discovery.discovered_extends[name] || EMPTY).any? do |raw|
+            resolved = @resolver.resolve_one(name, raw)
+            !resolved.nil? && ResolutionChain.extend_reshapes_instance?(@scope, resolved)
+          end
+        end
+
         def multi_file?(name)
           sites = @discovery.discovered_class_sources[name]
           !sites.nil? && sites.size >= 2
@@ -866,14 +1014,14 @@ module Rigor
 
         def project_entry(name, side)
           by_side = (@bucket[:interned][side] ||= {})
-          by_side[name] ||= Entry.new(name, side, nil, nil, false, name.to_s.split("::").last.freeze)
+          by_side[name] ||= Entry.new(name, side, nil, nil, false, name.to_s.split("::").last.freeze, nil)
         end
 
         def external_entry(owner, raw, side, superclass_edge)
           by_edge = ((@bucket[:externals][side] ||= {})[superclass_edge] ||= {})
           by_owner = (by_edge[owner] ||= {})
           by_owner[raw] ||= Entry.new(nil, side, raw, @scope.ancestor_name_candidates(owner, raw).freeze,
-                                      superclass_edge, nil)
+                                      superclass_edge, nil, owner)
         end
       end
       private_constant :Builder