rigortype 0.4.5 → 0.4.6

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../reflection"
+require_relative "../method_parameter_binder"
+require_relative "../global_write_census"
+require_relative "unseen_ivar_writers"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #1154 — the class-ivar census types an `@x = x` write whose right-hand side reads a parameter of the
+      # enclosing instance `def` as that parameter's DECLARED type: the method's RBS signature, from `sig/` or from
+      # an rbs-inline `# @rbs` / `#:` annotation, read through {MethodParameterBinder}, the binder the method body's
+      # own entry scope uses. Without it the census typed the rvalue with no local bindings, so a constructor field
+      # read `Dynamic[top]` in every sibling method even where `sig/` declared `initialize: (String x) -> void`.
+      #
+      # The census is flow-free, so a write is credited only where the parameter can hold nothing but its
+      # argument. {.collect} answers `{write node => declared type}` (an identity Hash) for the writes that pass
+      # 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 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 ||= …`,
+      #   a `rescue => x` or pattern target);
+      # - the owner is a class, not a module (a module's ivar belongs to whichever object includes it), and its
+      #   RBS declares the method itself (`defined_in`), so an inherited signature never types a redefinition;
+      # - the signature has exactly one overload, whose parameter lists are typed (`(?)` declines) and mention no
+      #   type variable (a class `Box[T]` or a method `[T]` variable is unsolved at the write);
+      # - 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;
+      # - 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.
+      module DeclaredParamWrites
+        EMPTY = {}.compare_by_identity.freeze
+
+        SCOPE_BARRIERS = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+        private_constant :SCOPE_BARRIERS
+
+        BLOCK_NODES = [Prism::BlockNode, Prism::LambdaNode].freeze
+        private_constant :BLOCK_NODES
+
+        OPAQUE_EVAL_CALLS = %i[eval instance_eval class_eval module_eval instance_exec class_exec
+                               module_exec].to_set.freeze
+        private_constant :OPAQUE_EVAL_CALLS
+
+        WRITER_SCOPE_KEY = :__rigor_declared_param_writer_scope__
+        private_constant :WRITER_SCOPE_KEY
+
+        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)
+          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
+        end
+
+        def writer_scope(scope) = Thread.current[WRITER_SCOPE_KEY] || 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.
+        def collect(def_node, class_name, scope)
+          return EMPTY if def_node.body.nil? || def_node.parameters.nil?
+
+          written = Set.new
+          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?
+
+          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]
+            acc[write] = type if type && !UnseenIvarWriters.possible?(writers, class_name, write.name)
+          end
+          credited.empty? ? EMPTY : credited
+        rescue StandardError
+          EMPTY
+        end
+
+        # Collects the `@x = local` 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.
+        #
+        # Answers `:opaque` when the body can rewrite a local through code the scan cannot read: a `binding` call, or
+        # an `eval`-family call given an argument ({OPAQUE_EVAL_CALLS}).
+        def scan(node, written, writes, in_block:)
+          return unless node.is_a?(Prism::Node)
+          return if SCOPE_BARRIERS.any? { |klass| node.is_a?(klass) }
+
+          case node
+          when Prism::LocalVariableWriteNode, Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+               Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableTargetNode
+            written << node.name
+          when Prism::CallNode
+            return :opaque if opaque_call?(node)
+          end
+          writes << node if !in_block && local_read_write?(node)
+          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
+          end
+          nil
+        end
+
+        # `binding` hands the frame's locals to code that may write them (`binding.eval("x = 's'")`,
+        # `Helper.rw(binding)`); a string passed to an `eval`-family call is code the scan cannot read.
+        def opaque_call?(node)
+          return true if node.name == :binding
+
+          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
+          return {} if environment.nil?
+          return {} if environment.rbs_module?(class_name)
+          return {} unless Reflection.project_declared_class?(class_name, environment: environment)
+
+          rbs_method = Reflection.instance_method_definition(class_name, def_node.name, environment: environment)
+          return {} unless sole_typed_overload?(rbs_method, class_name)
+
+          binder = MethodParameterBinder.new(environment: environment, class_path: class_name, singleton: false)
+          binder.bind(def_node).reject { |_name, type| type.is_a?(Type::Dynamic) }
+        end
+
+        def sole_typed_overload?(rbs_method, class_name)
+          return false if rbs_method.nil? || rbs_method.defined_in.to_s.delete_prefix("::") != class_name
+
+          method_types = rbs_method.method_types
+          return false unless method_types.size == 1
+
+          function = method_types.first.type
+          function.respond_to?(:required_positionals) && function.free_variables.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../global_write_census"
+require_relative "../reflective_ivar_write"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #1154 — whether code the class-ivar census of `class_name` never walks may write the instance variable
+      # `ivar` on its instances, where a literal write in the same place would answer for it too. The census joins
+      # only the writes in the class's own bodies in one file, so a declared-parameter write ({DeclaredParamWrites}) is
+      # credited only when this answers false. The standard is parity with a literal write: what an unknown object's
+      # code may do is accepted, as it is for `@x = 1` (the {IvarWriterCensus} policy), and what the class or its
+      # ancestors do is not:
+      #
+      # - a project ancestor on the class's instance resolution chain (a superclass, or a module it or an ancestor
+      #   includes or prepends) defines the writer `ivar=` (an `attr_writer` / `attr_accessor` or a `def`), or has an
+      #   instance `def` whose body writes the ivar, in any form, or calls `instance_variable_set` on `self` (`super`
+      #   from the class's `initialize`, or an inherited setter, runs it on the instance);
+      # - an ancestor the project does not declare is reached through a superclass edge and is not a core class (a
+      #   gem's or a Ruby-written stdlib class's `initialize` may write any ivar), or the chain was cut;
+      # - the class or a project ancestor holds an open-world self writer in an instance body (`[:ivar_set_class, …]`,
+      #   `def configure(&b) = instance_eval(&b)`);
+      # - a file other than this one writes the same ivar in an instance `def` of the class (`[:own_write, …]`): the
+      #   census is per file, so a reopening's write would not be joined;
+      # - the project's {GlobalWriteCensus} records a named write to the ivar from outside the object
+      #   (`o.instance_variable_set(:@x, v)`, `o.instance_eval { @x = v }`).
+      #
+      # An ancestor's `define_method` body is not read: the ancestor's own file census sees it, this file does not.
+      #
+      # Every read files its ADR-46 edge: each project ancestor's declaring files ({Scope::ResolutionChain.record_entry})
+      # and each of its `def`s read ({Scope#user_def_for}), and the `ivar_set:`, `ivar_set_class:` and `own_write:`
+      # name keys the incremental session fires when a file's entries move.
+      module UnseenIvarWriters
+        BARRIERS = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+        private_constant :BARRIERS
+
+        module_function
+
+        def possible?(scope, class_name, ivar)
+          census = census(scope)
+          foreign_write?(census, ivar) || class_open_world?(census, class_name) ||
+            other_file_write?(census, class_name, ivar) || ancestor_write?(scope, census, class_name, ivar)
+        end
+
+        def census(scope)
+          census = scope.discovered_global_write_census
+          pre_eval = scope.environment&.project_patched_methods&.write_census
+          pre_eval.nil? || pre_eval.empty? ? census : census | pre_eval
+        end
+
+        def foreign_write?(census, ivar)
+          Analysis::DependencyRecorder.read_name(:ivar_set, ivar.to_s) if Analysis::DependencyRecorder.active?
+          census.include?([:ivar_set, ivar])
+        end
+
+        def class_open_world?(census, class_name)
+          # A guard: the entry comes from an instance body of the class (or an ancestor), whose declaring files the
+          # class's own resolution already re-checks; kept so the read states its own dependency.
+          Analysis::DependencyRecorder.read_name(:ivar_set_class, class_name) if Analysis::DependencyRecorder.active?
+          census.include?([:ivar_set_class, class_name])
+        end
+
+        # More than one file records an instance-`def` write of the ivar for the class: this file's census sees its
+        # own only. An entry no path tags (a census built outside the project pre-pass) counts as this file.
+        def other_file_write?(census, class_name, ivar)
+          if Analysis::DependencyRecorder.active?
+            Analysis::DependencyRecorder.read_name(:own_write, "#{class_name}##{ivar}")
+          end
+          paths = census.filter_map do |entry|
+            entry[3] if entry.size == 4 && entry[0] == :own_write && entry[1] == class_name && entry[2] == ivar
+          end
+          paths.uniq.size > 1
+        end
+
+        def ancestor_write?(scope, census, class_name, ivar)
+          chain = Scope::ResolutionChain.for(scope, class_name, :instance, :constants)
+          return true if chain.truncated?
+
+          setter = :"#{ivar.to_s.delete_prefix('@')}="
+          chain.entries.any? do |entry|
+            next false if entry.side != :instance || entry.name == class_name
+
+            # A guard: the class body's own `include` / `<` resolution already files this edge; kept so the read
+            # states its own dependency.
+            Scope::ResolutionChain.record_entry(scope, entry, :instance) if Analysis::DependencyRecorder.active?
+            next foreign_superclass?(scope, entry) if entry.external?
+
+            class_open_world?(census, entry.name) || scope.discovered_method?(entry.name, setter, :instance) ||
+              defs_write?(scope, entry.name, ivar)
+          end
+        end
+
+        # A superclass the project does not declare that the interpreter does not implement: a gem's class, or a
+        # stdlib one written in Ruby (`Logger` sets `@level` in `initialize`), may write any ivar of its subclass's
+        # instances. A module the project does not declare is left alone.
+        def foreign_superclass?(scope, entry)
+          return false unless entry.superclass_edge
+
+          loader = scope.environment&.rbs_loader
+          entry.candidates.empty? || entry.candidates.none? { |name| loader&.core_class?(name) }
+        end
+
+        def defs_write?(scope, owner, ivar)
+          (scope.discovered_def_nodes[owner] || {}).each_key.any? do |method_name|
+            node = scope.user_def_for(owner, method_name)
+            node.is_a?(Prism::DefNode) && writes?(node.body, ivar)
+          end
+        end
+
+        def reflective_name(node) = ReflectiveIvarWrite.literal_name(node)
+
+        def writes?(node, ivar)
+          return false unless node.is_a?(Prism::Node)
+          return false if BARRIERS.any? { |klass| node.is_a?(klass) }
+
+          case node
+          when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+               Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+            return true if node.name == ivar
+          end
+          # A literal `instance_variable_set` of the ivar, or one whose name no literal spells.
+          return true if ReflectiveIvarWrite.self_write?(node) && [ivar, nil].include?(reflective_name(node))
+
+          node.rigor_each_child { |child| return true if writes?(child, ivar) }
+          false
+        end
+      end
+    end
+  end
+end