rigortype 0.4.6 → 0.4.8

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../source/node_walker"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #2291 — the class-ivar census types an `@x = LIT` write from the type the constant's own write binds, the
+      # same way a method body reads `LIT`. The census runs before the file's in-source constant table is seeded, so
+      # without it the write typed under no constant table and a reader over the ivar (`def q = @q`) read `Dynamic[top]`
+      # where `def g = LIT` read the constant's type.
+      #
+      # One instance serves one census walk. The file's constant table is built on the first constant-valued write, so
+      # a file with none pays nothing; it is built as {ScopeIndexer#index} builds it later (typed under the census's
+      # scope, merged over the scope's project seed, a mutated literal widened), and resolved through the ordinary
+      # constant lookup. {#type_of} answers nil, leaving the write's ordinary typing, when:
+      #
+      # - the value is not a constant read (`LIT`, `A::LIT`, `::LIT`); a path over anything else (`self.class::LIT`)
+      #   resolves to nothing, as it does in a method body;
+      # - the file may rebind a constant of that last segment: a second write in any form, an operator, `||=` or `&&=`
+      #   write, a multiple-assignment target, or a `const_set` / `remove_const` naming it — or naming anything but a
+      #   literal, which may be it.
+      #
+      # A constant another file assigns resolves only through the scope's own project seed, as it did before.
+      class ConstantIvarValue
+        WRITE_NODES = [Prism::ConstantWriteNode, Prism::ConstantPathWriteNode].freeze
+        REBIND_NODES = [Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode,
+                        Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode,
+                        Prism::ConstantPathAndWriteNode, Prism::ConstantTargetNode,
+                        Prism::ConstantPathTargetNode].freeze
+        REBIND_CALLS = %i[const_set remove_const].freeze
+        ANY_NAME = :any
+        private_constant :WRITE_NODES, :REBIND_NODES, :REBIND_CALLS, :ANY_NAME
+
+        def initialize(root, scope)
+          @root = root
+          @scope = scope
+        end
+
+        # The type `value` reads under the file's constant table, or nil when the write keeps its ordinary typing.
+        def type_of(value, scope)
+          return nil unless value.is_a?(Prism::ConstantReadNode) || value.is_a?(Prism::ConstantPathNode)
+          return nil if rebound?(value.name)
+
+          scope.with_discovery(scope.discovery.with(in_source_constants: constants)).type_of(value)
+        end
+
+        private
+
+        def constants
+          @constants ||= begin
+            literal_mutations = ScopeIndexer.collect_literal_receiver_mutations(@root)
+            per_file = ScopeIndexer.widen_mutated_constants(
+              ScopeIndexer.build_in_source_constants(@root, @scope), literal_mutations[:constants]
+            )
+            ScopeIndexer.merge_seeded_constants(@scope.in_source_constants, per_file)
+          end
+        end
+
+        def rebound?(name)
+          @rebound ||= rebound_names
+          @rebound.include?(ANY_NAME) || @rebound.include?(name)
+        end
+
+        def rebound_names
+          written = Set.new
+          rebound = Set.new
+          Source::NodeWalker.each(@root) do |node|
+            case node
+            when *WRITE_NODES
+              name = write_name(node)
+              rebound << name unless written.add?(name)
+            when *REBIND_NODES then rebound << write_name(node)
+            when Prism::CallNode then rebound << call_name(node) if REBIND_CALLS.include?(node.name)
+            end
+          end
+          rebound
+        end
+
+        def write_name(node) = node.respond_to?(:target) ? node.target.name : node.name
+
+        def call_name(node)
+          argument = node.arguments&.arguments&.first
+          return argument.unescaped.to_sym if argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+
+          ANY_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -4,8 +4,10 @@ require "prism"
 
 require_relative "../../reflection"
 require_relative "../method_parameter_binder"
+require_relative "../../typing_state"
 require_relative "../global_write_census"
 require_relative "unseen_ivar_writers"
+require_relative "derived_param_value"
 
 module Rigor
   module Inference
@@ -21,7 +23,13 @@ module Rigor
       # every gate, and {EMPTY} otherwise; an absent write keeps the census's ordinary rvalue typing, so a declined
       # case reads exactly what it read before:
       #
-      # - the write's value is a bare read of the parameter (`@x = x`), not an expression over it;
+      # - the write's value reads at least one parameter, and every local it reads is a parameter with a declared type.
+      #   A bare read (`@x = x`) records that type; an expression over parameters (`@x = x.dup.freeze`,
+      #   `@x = Array(x)`, `@x = f ? x : y`, issue #2321) records the value typed with each parameter it reads bound to
+      #   its declared type, unless {DerivedParamValue} declines it (a parameter that holds `untyped` at any depth or
+      #   has a default outside its declared type, or a call argument whose type may match a narrower overload). A
+      #   value that holds a block, a lambda or a nested `def` is not credited: their own parameters are locals the
+      #   scan does not bind;
       # - the write is not inside a block or a lambda, so a block parameter of the same name and a block that runs
       #   under another `self` (`instance_eval`, `Class.new`, `define_method`) never borrow the method's parameter;
       # - the method body never writes the parameter, in any form and at any depth (`x = Integer(x)`, `x ||= …`,
@@ -33,8 +41,8 @@ module Rigor
       # - the class's primary RBS declaration is the project's (`sig/` or rbs-inline), not core, stdlib or a gem's:
       #   a project reopening of a library class (`Thread::SizedQueue#initialize`) would otherwise borrow the
       #   library's parameter type for its own `def`;
-      # - the body neither calls `binding` nor passes code to `eval` / `instance_eval` / `class_eval` /
-      #   `module_eval` / `instance_exec` as an argument, any of which can rewrite the parameter unseen;
+      # - the body neither calls `binding` nor passes code as an argument to an `eval`-family call
+      #   (`OPAQUE_EVAL_CALLS`), any of which can rewrite the parameter unseen;
       # - nothing outside the class's own census may write the ivar ({UnseenIvarWriters}): no project ancestor, and
       #   no other object's code (`o.instance_variable_set(:@x, v)`);
       # - the declared type is not `untyped`, which is what the write already records.
@@ -51,27 +59,27 @@ module Rigor
                                module_exec].to_set.freeze
         private_constant :OPAQUE_EVAL_CALLS
 
-        WRITER_SCOPE_KEY = :__rigor_declared_param_writer_scope__
-        private_constant :WRITER_SCOPE_KEY
+        # ADR-129 WD1 — a Frame: the scope is installed around a census and restored on the way out.
+        WRITER_SCOPE = TypingState.frame(
+          :declared_param_writer_scope,
+          reason: "the scope whose project tables the writer gates read, installed per census",
+          # G1′: the census types its defaults under the Frame, but only the writer gates, outside `type_of`, read it.
+          typing_never_reads: true
+        )
+        private_constant :WRITER_SCOPE
 
         module_function
 
         # Runs the block with `scope` as the one whose project tables the unseen-writer and single-file gates read, in
-        # place of the census's own scope. `rigor sig-gen` indexes each file under a scope that carries no project
-        # tables, so without it another file's writer, ancestor or reopening would go unseen.
-        def with_writer_scope(scope)
+        # place of the census's own scope. `rigor sig-gen` indexes each file over the project tables less the member
+        # layouts; this scope carries all of them, so another file's writer, ancestor or reopening is seen.
+        def with_writer_scope(scope, &)
           return yield if scope.nil?
 
-          previous = Thread.current[WRITER_SCOPE_KEY]
-          Thread.current[WRITER_SCOPE_KEY] = scope
-          begin
-            yield
-          ensure
-            Thread.current[WRITER_SCOPE_KEY] = previous
-          end
+          TypingState.current.with(WRITER_SCOPE, scope, &)
         end
 
-        def writer_scope(scope) = Thread.current[WRITER_SCOPE_KEY] || scope
+        def writer_scope(scope) = TypingState.current[WRITER_SCOPE] || scope
 
         # `{InstanceVariableWriteNode => Rigor::Type}` for `def_node`'s creditable writes, or {EMPTY}. The caller
         # passes only an instance `def`: a singleton body's `@x` is the class object's.
@@ -82,13 +90,15 @@ module Rigor
           writes = []
           return EMPTY if scan(def_node.body, written, writes, in_block: false) == :opaque
 
-          writes.reject! { |write| written.include?(write.value.name) }
-          return EMPTY if writes.empty?
+          reads = unwritten_reads(writes, written)
+          return EMPTY if reads.empty?
 
           types = declared_types(def_node, class_name, scope)
           writers = writer_scope(scope)
-          credited = writes.each_with_object({}.compare_by_identity) do |write, acc|
-            type = types[write.value.name]
+          credited = reads.each_with_object({}.compare_by_identity) do |(write, names), acc|
+            next unless names.all? { |name| types.key?(name) }
+
+            type = value_type(write.value, names, types, def_node, scope)
             acc[write] = type if type && !UnseenIvarWriters.possible?(writers, class_name, write.name)
           end
           credited.empty? ? EMPTY : credited
@@ -96,7 +106,45 @@ module Rigor
           EMPTY
         end
 
-        # Collects the `@x = local` writes outside every block, and the name of every local the body writes in
+        # `{write => names of the locals its value reads}` for each write whose value reads at least one local and no
+        # local the body writes.
+        def unwritten_reads(writes, written)
+          writes.each_with_object({}.compare_by_identity) do |write, acc|
+            names = parameter_reads(write.value)
+            next if names.nil? || names.empty? || names.any? { |name| written.include?(name) }
+
+            acc[write] = names
+          end
+        end
+
+        # The names of the locals `value` reads, or nil when it holds a block, a lambda or a scope barrier.
+        def parameter_reads(value, names = Set.new)
+          return names unless value.is_a?(Prism::Node)
+          return nil if BLOCK_NODES.any? { |klass| value.is_a?(klass) }
+          return nil if SCOPE_BARRIERS.any? { |klass| value.is_a?(klass) }
+
+          names << value.name if value.is_a?(Prism::LocalVariableReadNode)
+          value.rigor_each_child do |child|
+            return nil if parameter_reads(child, names).nil?
+          end
+          names
+        end
+
+        # A bare read takes the declared type itself; an expression over the parameters is typed with each bound to
+        # its declared type, unless {DerivedParamValue} declines it.
+        def value_type(value, names, types, def_node, scope)
+          return types[value.name] if value.is_a?(Prism::LocalVariableReadNode)
+          return nil if DerivedParamValue.declined?(names, types, def_node, scope)
+
+          bound = names.reduce(scope) { |acc, name| acc.with_local(name, types[name]) }
+          return nil if DerivedParamValue.overload_sensitive_argument?(value, bound)
+
+          bound.type_of(value)
+        rescue StandardError
+          nil
+        end
+
+        # Collects the `@x = …` writes outside every block, and the name of every local the body writes in
         # any form at any depth. A read at depth zero outside a block names the method's own local, which is the
         # parameter when the body never writes the name.
         #
@@ -113,7 +161,7 @@ module Rigor
           when Prism::CallNode
             return :opaque if opaque_call?(node)
           end
-          writes << node if !in_block && local_read_write?(node)
+          writes << node if !in_block && node.is_a?(Prism::InstanceVariableWriteNode)
           inner = in_block || BLOCK_NODES.any? { |klass| node.is_a?(klass) }
           node.rigor_each_child do |child|
             return :opaque if scan(child, written, writes, in_block: inner) == :opaque
@@ -129,10 +177,6 @@ module Rigor
           OPAQUE_EVAL_CALLS.include?(node.name) && !(node.arguments&.arguments || []).empty?
         end
 
-        def local_read_write?(node)
-          node.is_a?(Prism::InstanceVariableWriteNode) && node.value.is_a?(Prism::LocalVariableReadNode)
-        end
-
         # The declared, non-`untyped` type of each parameter, or `{}` when a gate declines the method.
         def declared_types(def_node, class_name, scope)
           environment = scope&.environment

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../acceptance"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #2321 — the declines {DeclaredParamWrites} applies to a write whose value is an expression over declared
+      # parameters, beyond the ones a bare read (`@x = x`) shares. Each says the expression's type, evaluated with the
+      # parameters bound to their declared types, may not be the type the ivar holds at runtime:
+      #
+      # - a parameter whose declared type holds `untyped` at any depth (`Array[untyped]`, #2325): the answer is built
+      #   on the part the author left untyped;
+      # - an optional parameter whose default value's type is not within its declared type
+      #   (`def initialize(x = nil)` under `(?Integer x)`): the value may run on the default, which the binding does not
+      #   carry;
+      # - an argument of any call in the value (`a + b`, `a + (b > 0 ? b : 0.5)`, `a[i]`, `Array(x)`, `super(…)`,
+      #   `yield(…)`), typed under the parameter bindings, whose type is anything but a literal or an instance of a
+      #   class no RBS class names as its superclass: the engine picks the first overload such an argument matches
+      #   (`Integer#+` given `Integer | Float` answers `Integer`), not the join of every overload it may reach. A
+      #   receiver dispatches per member and is not declined. A splat or keyword argument types as neither, so it
+      #   declines too.
+      module DerivedParamValue
+        module_function
+
+        # Whether a write over the parameters `names`, declared `types`, is not credited for a parameter it reads.
+        def declined?(names, types, def_node, scope)
+          names.any? do |name|
+            carries_dynamic?(types[name]) || default_outside?(def_node, name, types[name], scope)
+          end
+        end
+
+        # Whether a call in `value` takes an argument whose type, under the parameter bindings of `bound`, may match an
+        # overload narrower than itself.
+        def overload_sensitive_argument?(value, bound)
+          return false unless value.is_a?(Prism::Node)
+
+          if value.is_a?(Prism::CallNode) || value.is_a?(Prism::SuperNode) || value.is_a?(Prism::YieldNode)
+            arguments = value.arguments&.arguments || []
+            return true if arguments.any? { |argument| overload_sensitive?(bound.type_of(argument), bound) }
+          end
+          value.rigor_each_child { |child| return true if overload_sensitive_argument?(child, bound) }
+          false
+        end
+
+        def carries_dynamic?(type)
+          case type
+          when Type::Dynamic then true
+          when Type::Union, Type::Intersection then type.members.any? { |member| carries_dynamic?(member) }
+          when Type::Nominal then type.type_args.any? { |arg| carries_dynamic?(arg) }
+          when Type::Tuple then type.elements.any? { |element| carries_dynamic?(element) }
+          when Type::HashShape then type.pairs.each_value.any? { |pair_value| carries_dynamic?(pair_value) }
+          # No RBS parameter spelling yields a refinement over `untyped`; the arm keeps the walk total.
+          when Type::Difference, Type::Refined then carries_dynamic?(type.base)
+          else false
+          end
+        end
+
+        # Whether an argument of this declared type may match an overload narrower than itself.
+        def overload_sensitive?(type, scope)
+          case type
+          when Type::Constant then false
+          when Type::Nominal then !leaf_class?(type.class_name, scope&.environment)
+          else true
+          end
+        end
+
+        def leaf_class?(class_name, environment)
+          return false if environment.nil? || environment.rbs_module?(class_name)
+          # A guard: a validated RBS signature names no unknown class, so this answers only for a broken environment.
+          return false unless environment.class_known?(class_name)
+
+          superclasses = environment.rbs_loader&.superclass_names
+          return false if superclasses.nil? || superclasses.empty?
+
+          !superclasses.include?(class_name.delete_prefix("::"))
+        end
+
+        # Whether `name` is an optional parameter of `def_node` whose default value's type is not within `declared`.
+        def default_outside?(def_node, name, declared, scope)
+          default = default_value(def_node.parameters, name)
+          return false if default.nil?
+
+          default_type = scope.type_of(default)
+          return true if carries_dynamic?(default_type)
+
+          !Acceptance.accepts(declared, default_type).yes? && !empty_collection_within?(declared, default_type)
+        end
+
+        # An empty `[]` or `{}` default is within any `Array[T]` or `Hash[K, V]` the declaration names, which the
+        # acceptance check answers only `maybe` (the empty literal has no element type to compare).
+        def empty_collection_within?(declared, default_type)
+          collection =
+            if default_type.is_a?(Type::Tuple) && default_type.elements.empty? then "Array"
+            elsif default_type.is_a?(Type::HashShape) && default_type.pairs.empty? then "Hash"
+            end
+          return false if collection.nil?
+
+          members = declared.is_a?(Type::Union) ? declared.members : [declared]
+          members.any? { |member| member.is_a?(Type::Nominal) && member.class_name == collection }
+        end
+
+        def default_value(parameters, name)
+          candidates = parameters.optionals + parameters.keywords
+          candidates.find { |param| param.respond_to?(:value) && param.name == name }&.value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #2499 — the accumulator idiom: a heap slot (an instance, class or global variable, or a constant)
+      # seeded with an empty literal and filled later, often from a method, a subclass, a mixin or another file
+      # the census cannot see. The seed is never proof that the slot is still empty, so the census records it
+      # without its emptiness: `""` and `+""` as `String`, `[]` as `Array[untyped]`, `{}` as
+      # `Hash[untyped, untyped]`. `String.new`, `Array.new` and `Hash.new` already type as their nominal.
+      #
+      # Only the empty spellings count. A non-empty literal (`@order = "asc"`, `MODES = %w[a b]`,
+      # `@opts = { a: 1 }`) keeps its exact type: such slots are modes and config tables, and an RBS parameter
+      # typed `"asc" | "desc"` must still accept them. A local keeps its flow precision; this applies only where
+      # the census seeds a heap slot.
+      module EmptySeed
+        module_function
+
+        # `type` with its emptiness dropped when `node` is an empty seed literal, otherwise `type` itself.
+        def erase(node, type)
+          return type unless empty_seed?(node)
+
+          members = type.is_a?(Type::Union) ? type.members : [type]
+          Type::Combinator.union(*members.map { |member| unpinned(member) })
+        end
+
+        # `{ name => value node }` for each leading target of a multiple assignment whose right-hand side is a literal
+        # list (`@a, @b = {}, []`), so each slot is erased from its own element. Empty for any other right-hand side.
+        def multi_write_values(node)
+          value = node.value
+          return EMPTY_VALUES unless value.is_a?(Prism::ArrayNode)
+
+          elements = value.elements
+          node.lefts.each_with_index.with_object({}) do |(target, index), values|
+            break values if index >= elements.size || elements[index].is_a?(Prism::SplatNode)
+            next unless target.respond_to?(:name)
+
+            values[target.name] = elements[index]
+          end
+        end
+
+        EMPTY_VALUES = {}.freeze
+        private_constant :EMPTY_VALUES
+
+        # A chained write (`@a = @b = ""`) stores the inner write's value in the outer slot too, so it is followed.
+        def empty_seed?(node)
+          case node
+          when Prism::StringNode then node.unescaped.empty?
+          when Prism::ArrayNode, Prism::HashNode then node.elements.empty?
+          when Prism::CallNode then copied_empty_seed?(node)
+          when *CHAINED_WRITES then empty_seed?(node.value)
+          else false
+          end
+        end
+
+        CHAINED_WRITES = [
+          Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode, Prism::ClassVariableWriteNode,
+          Prism::GlobalVariableWriteNode, Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+        ].freeze
+        private_constant :CHAINED_WRITES
+
+        # `+""`, the unfrozen empty String the accumulator idiom spells under `# frozen_string_literal: true`, and a
+        # `.dup` of an empty seed (`"".dup`, `[].dup`, `{}.dup`).
+        def copied_empty_seed?(node)
+          return false unless node.arguments.nil? && node.block.nil?
+
+          case node.name
+          when :+@ then node.receiver.is_a?(Prism::StringNode) && node.receiver.unescaped.empty?
+          when :dup then empty_seed?(node.receiver)
+          else false
+          end
+        end
+
+        def unpinned(member)
+          case member
+          when Type::Constant
+            member.value.is_a?(String) && member.value.empty? ? Type::Combinator.nominal_of("String") : member
+          when Type::Tuple
+            if member.elements.empty?
+              Type::Combinator.nominal_of("Array",
+                                          type_args: [Type::Combinator.untyped])
+            else
+              member
+            end
+          when Type::HashShape
+            return member unless member.pairs.empty?
+
+            Type::Combinator.nominal_of("Hash", type_args: [Type::Combinator.untyped, Type::Combinator.untyped])
+          else member
+          end
+        end
+        private_class_method :copied_empty_seed?, :unpinned
+      end
+    end
+  end
+end