rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/method_dispatcher/declared_constructor.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../../reflection"
+require_relative "../../type"
+require_relative "argument_nodes"
+require_relative "overload_selector"
+require_relative "rbs_dispatch"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #2884 — `X.new` through a `def self.new` that a project, gem or collection signature declares on `X` or
+      # on an ancestor of `X`. RBS models a constructor that answers another class this way (`email_address` declares
+      # `def self.new: (...) -> Address` on `EmailAddress`), and `MethodDispatcher#meta_new` answered `Nominal[X]` for
+      # every `Singleton[X].new` before any RBS tier ran. `meta_new` asks this module only after its curated lifts
+      # (`Array`, `Set`, `Hash`, `Struct`, `Class.new`, …) have declined, and keeps its `Nominal[X]` answer whenever
+      # this one is nil.
+      #
+      # The declaration counts only when it is an explicit `def self.new` (not the `new` RBS builds from `initialize`),
+      # every one of its definitions sits outside the `rbs` gem's core and stdlib trees
+      # ({Environment::RbsLoader#declared_outside_core_stdlib?}), and the class carrying it is not one core or stdlib
+      # declares. Core declares `Data.new: () -> bot` and `Ractor.new: … -> Ractor`, stdlib `Tempfile.new`; a project
+      # class inheriting one of those keeps the `Nominal` answer the curated tiers were written around.
+      #
+      # The declaration is found on `X`'s own RBS (which carries its RBS ancestors' singleton methods), or, for a
+      # Ruby-source class with no RBS of its own, on the first RBS-known class of its singleton
+      # {Scope::ResolutionChain}. A project entry ahead of it that defines `new` ends the walk with no answer: that
+      # method is the one Ruby runs. An inherited declaration that answers the instance
+      # ({Environment::RbsLoader#answers_instance_for_subclass?}) answers `Nominal[X]`; otherwise `instance`, and an
+      # overload returning the declaring class itself, read the receiver class, and `self` reads its class object.
+      #
+      # Nil (so `Nominal[X]`) when no overload takes the arguments (argument checking of `.new` is not this tier's
+      # job), and when the return translates to an untyped, `top` or `bot` answer, which would lose the precision
+      # `Nominal[X]` already has.
+      module DeclaredConstructor
+        # An entry of the singleton chain ahead of any declaring class defines `new` itself (in Ruby source, or as an
+        # `extend`ed module's RBS instance method), so that method is the one Ruby runs and the walk answers nothing.
+        OTHER_NEW = :other_new
+        private_constant :OTHER_NEW
+
+        module_function
+
+        def try_dispatch(class_name, context)
+          environment = context.environment
+          loader = environment&.rbs_loader
+          return nil if loader.nil? || !loader.respond_to?(:honoured_singleton_new?)
+
+          definition = declared_new(class_name, environment, loader, context.scope)
+          return nil if definition.nil? || !overload_matches?(definition, class_name, context)
+
+          owner = definition.defined_in.to_s.delete_prefix("::")
+          # The same test the walk's gate reads ({Environment::RbsLoader#singleton_new_departs_from_instance?}), so
+          # an inherited declaration that answers the instance answers `Nominal[receiver]` whether or not the gate let
+          # the walk run.
+          return nil if owner != class_name && loader.answers_instance_for_subclass?(definition)
+
+          answer = RbsDispatch.declared_singleton_return(context, definition, class_name)
+          answer = repoint_owner(answer, owner, class_name)
+          answer if usable?(answer)
+        end
+
+        class << self
+          private
+
+          def declared_new(class_name, environment, loader, scope)
+            owner = declaring_class(class_name, environment, loader, scope)
+            return nil if owner.nil?
+
+            definition = Rigor::Reflection.singleton_method_definition(owner, :new, environment: environment)
+            definition if definition && loader.honoured_singleton_new?(definition)
+          end
+
+          # `class_name` itself when RBS knows it; else the first RBS-known class on its singleton
+          # {Scope::ResolutionChain}, read in Ruby's order. Nil when a project entry ahead of it defines `new` (a
+          # `def self.new`, or an `extend`ed module's `def new`), when the chain reaches none, and when the chain does
+          # not stand (a fork or an unplaced mixin edge, where the tables cannot say which world ran).
+          #
+          # The walk runs only when some loaded declaration fails {Environment::RbsLoader#answers_instance_for_subclass?}
+          # ({Environment::RbsLoader#singleton_new_departs_from_instance?}); `try_dispatch` answers `Nominal[X]` for an
+          # inherited declaration that passes it, so without one the walk could change nothing. When it runs
+          # it files its reads whatever it answers: a later edit that puts such a declaration on the chain changes
+          # the answer, and the caller must be re-checked then.
+          def declaring_class(class_name, environment, loader, scope)
+            return class_name if Rigor::Reflection.rbs_class_known?(class_name, environment: environment)
+            return nil if scope.nil? || !loader.singleton_new_departs_from_instance?
+
+            chain = Scope::ResolutionChain.for(scope, class_name.to_s, :singleton, :methods)
+            found = first_new_owner(chain, scope, environment)
+            verdict = chain.settle(scope, found, owner: nil) { |retro| first_new_owner(retro, scope, environment) }
+            found unless found.nil? || found == OTHER_NEW || verdict != :chain
+          end
+
+          # The first entry on `chain` that answers `new`: an RBS-known class's name, or {OTHER_NEW} for an entry that
+          # defines it otherwise. An `extend`ed module is not a class object `new` is declared on, but one whose
+          # instance side declares `new` (in Ruby source or in RBS) puts that method ahead of the superclass's, so it
+          # stops the walk.
+          def first_new_owner(chain, scope, environment)
+            chain.search(scope) do |entry|
+              if entry.external?
+                extended_rbs_new = !entry.superclass_edge && rbs_instance_new?(entry.candidates, environment)
+                next OTHER_NEW if extended_rbs_new
+                next unless entry.superclass_edge
+
+                entry.candidates.find { |name| Rigor::Reflection.rbs_class_known?(name, environment: environment) }
+              elsif entry.side == :singleton && Rigor::Reflection.rbs_class_known?(entry.name, environment: environment)
+                entry.name
+              elsif scope.discovered_method?(entry.name, :new, entry.side) ||
+                    (entry.side == :instance && rbs_instance_new?([entry.name], environment))
+                OTHER_NEW
+              end
+            end
+          end
+
+          def rbs_instance_new?(names, environment)
+            names.any? { |name| Rigor::Reflection.instance_method_definition(name, :new, environment: environment) }
+          end
+
+          # A genuine match only: the selector's first-overload fallback would answer a declaration the call does
+          # not take.
+          def overload_matches?(definition, class_name, context)
+            args = context.args || []
+            !OverloadSelector.select_declared(
+              definition, args, Type::Combinator.singleton_of(class_name), Type::Combinator.nominal_of(class_name),
+              {}, !context.block_type.nil?, context.environment, true,
+              ArgumentNodes.keyword_hash_last?(context.call_node, args), nil, true
+            ).empty?
+          end
+
+          # A return naming the declaring class itself (`def self.new: [T] (T) -> Box[T]`) is the constructor's own
+          # class, so a subclass inheriting it answers the subclass, as `instance` does; generic arguments name the
+          # owner's parameters and are dropped with it. A foreign return (`EmailAddress` -> `Address`) stays.
+          def repoint_owner(answer, owner, class_name)
+            return answer if owner == class_name
+
+            case answer
+            when Type::Nominal
+              answer.class_name == owner ? Type::Combinator.nominal_of(class_name) : answer
+            when Type::Union
+              Type::Combinator.union(*answer.members.map { |member| repoint_owner(member, owner, class_name) })
+            else answer
+            end
+          end
+
+          def usable?(answer)
+            !(answer.nil? || answer.is_a?(Type::Dynamic) || answer.is_a?(Type::Top) || answer.is_a?(Type::Bot))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/facet_distribution.rb

@@ -119,7 +119,7 @@ module Rigor
         # `Dynamic`, the untyped carrier, a facet that is only `nil`, one wider than {MEMBER_LIMIT}, or one with a
         # member that is not sealed, an untyped member included.
         def facet_members(arg)
-          return nil unless arg.is_a?(Type::Dynamic) && !arg.static_facet.is_a?(Type::Top)
+          return nil unless arg.is_a?(Type::Dynamic) && !Type::Combinator.untyped?(arg)
 
           facet = arg.static_facet
           members = (facet.is_a?(Type::Union) ? facet.members : [facet]).reject { |member| nil_value?(member) }

data/lib/rigor/inference/method_dispatcher/imprecise_argument.rb

@@ -20,12 +20,12 @@ module Rigor
         module_function
 
         # The literal `untyped` carrier, `Dynamic[top]`.
-        def untyped?(type) = type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+        def untyped?(type) = Type::Combinator.untyped?(type)
 
         # The untyped carrier itself, or a union or `Dynamic` holding it at any depth.
         def imprecise?(type)
           case type
-          when Type::Dynamic then type.static_facet.is_a?(Type::Top) || imprecise?(type.static_facet)
+          when Type::Dynamic then Type::Combinator.untyped?(type) || imprecise?(type.static_facet)
           when Type::Union then type.members.any? { |member| imprecise?(member) }
           else false
           end

data/lib/rigor/inference/method_dispatcher/interface_shape.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../type"
+require_relative "../../typing_state"
+require_relative "../../memo_audit"
+require_relative "argument_nodes"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # ADR-130 WD3 — the overload-shape rule for a call on a `Rigor::Plugin` interface value. The argument rules
+      # never check a call on a `Dynamic` receiver, so nothing else would notice a call no overload of the member
+      # takes; without this rule dispatch took whichever overload the selector's fallback picked, and that
+      # overload's return made the next call wrong (`xs.each.with_index` read the block overload's
+      # `Array[Integer]`). A call resolves only through the overloads that take its shape:
+      #
+      # - a block when the call passes one, and no required block when it does not;
+      # - the positional count, within required plus optional unless the overload has a rest parameter;
+      # - no required keyword the call omits.
+      #
+      # A shape the AST cannot state, a splat (`*xs`), a keyword splat (`**opts`) or a forwarded `...`, is taken
+      # by no overload, so the call reads `untyped` as it does on master.
+      module InterfaceShape
+        # ADR-130 WD5 — the dispatch-off flag {.without_dispatch} installs (`RbsDispatch.without_interface_dispatch`).
+        DISPATCH_OFF = TypingState.frame(
+          :interface_dispatch_off, reason: "a flag installed around a dispatch-off run (sig-gen, the parity harness)",
+                                   witness: "spec/fixtures/typing_state_witnesses/interface_erasure.rb"
+        )
+        private_constant :DISPATCH_OFF
+
+        module_function
+
+        # Runs the block with interface dispatch switched off.
+        def without_dispatch(&)
+          MemoAudit.check_run_level_install(:interface_dispatch_off)
+          TypingState.current.with(DISPATCH_OFF, true, &)
+        end
+
+        # False inside {.without_dispatch}.
+        def dispatch? = TypingState.current[DISPATCH_OFF] != true
+
+        # `definition` narrowed to the overloads that take the call's shape (the definition itself when every
+        # overload does), or nil when none does.
+        #
+        # Nil too when more than one overload takes the shape and one of them has a parameter that mentions `self`
+        # (`(self other)`, `(Array[self] others)`): which of them the call reaches depends on whether an argument is
+        # the receiver's kind, and the interface names no class acceptance could decide that against. Read as a
+        # precise overload, `x.same(1)` against `(self) -> Integer | (Integer) -> String` answered the first one's
+        # `Integer`; the call reads `untyped` instead.
+        def accepting(definition, args, block:, call_node:)
+          shape = call_shape(args, call_node)
+          return nil if shape.nil?
+
+          positional, keywords = shape
+          defs = definition.defs.select { |type_def| takes?(type_def.type, positional, keywords, block) }
+          return nil if defs.empty?
+          return nil if defs.size > 1 && defs.any? { |type_def| self_parameter?(type_def.type.type) }
+
+          defs.size == definition.defs.size ? definition : definition.update(defs: defs)
+        end
+
+        # True when a parameter type of `function` mentions RBS `self`, at any depth.
+        def self_parameter?(function)
+          return false unless function.respond_to?(:required_positionals)
+
+          params = function.required_positionals + function.optional_positionals + function.trailing_positionals +
+                   function.required_keywords.values + function.optional_keywords.values
+          params << function.rest_positionals if function.rest_positionals
+          params << function.rest_keywords if function.rest_keywords
+          params.any? { |param| mentions_self?(param.type) }
+        end
+
+        def mentions_self?(rbs_type)
+          return true if rbs_type.is_a?(RBS::Types::Bases::Self)
+
+          rbs_type.each_type { |inner| return true if mentions_self?(inner) }
+          false
+        end
+
+        # True when the call's block is a block-pass whose value may be nil at runtime, so the call may run
+        # block-less: `&blk` unless `blk` is provably not nil ({.never_nil?}), and an anonymous `&`, which forwards
+        # the enclosing method's own block. `&:sym` is never nil.
+        def nilable_block_pass?(call_node, scope)
+          block = call_node.respond_to?(:block) ? call_node.block : nil
+          return false unless block.is_a?(Prism::BlockArgumentNode)
+
+          expression = block.expression
+          return true if expression.nil?
+          return false if expression.is_a?(Prism::SymbolNode)
+          return true if scope.nil?
+
+          !never_nil?(scope.type_of(expression))
+        end
+
+        # The classes a value of which may be `nil`: `NilClass` and its ancestors.
+        NIL_ANCESTORS = %w[NilClass Object BasicObject Kernel].freeze
+        private_constant :NIL_ANCESTORS
+
+        # True only for a type that provably excludes `nil`: a non-nil literal, an instance of a class `nil` is not
+        # (a `Proc`, a `Method`), a class object, or a shape. `top`, `Dynamic`, `Object` and anything this does not
+        # list may be `nil` (ADR-130 WD3, as amended).
+        def never_nil?(type)
+          case type
+          when Type::Union then type.members.all? { |member| never_nil?(member) }
+          when Type::Constant then !type.value.nil?
+          when Type::Nominal then !NIL_ANCESTORS.include?(type.class_name)
+          when Type::Refined, Type::Difference then never_nil?(type.base)
+          when Type::Singleton, Type::Tuple, Type::HashShape, Type::BoundMethod, Type::IntegerRange, Type::FloatRange,
+               Type::DataInstance, Type::StructInstance, Type::DataClass, Type::StructClass then true
+          else false
+          end
+        end
+
+        # `[positional count, keyword names or nil]`, or nil for a shape the AST cannot state, which includes a keyword
+        # hash whose keys are not all literal symbols. The keyword names are nil when the call passes no keyword hash.
+        def call_shape(args, call_node)
+          arguments = call_node.respond_to?(:arguments) ? call_node.arguments&.arguments : nil
+          return [args.size, nil] if arguments.nil? || arguments.size != args.size
+          return nil if arguments.any? { |node| opaque_argument?(node) }
+          return [args.size, nil] unless ArgumentNodes.keyword_hash_last?(call_node, args)
+
+          names = keyword_names(arguments.last)
+          names && [args.size - 1, names]
+        end
+
+        def opaque_argument?(node)
+          case node
+          when Prism::SplatNode, Prism::ForwardingArgumentsNode then true
+          when Prism::KeywordHashNode then node.elements.any?(Prism::AssocSplatNode)
+          else false
+          end
+        end
+
+        # The literal keyword names of a keyword hash, or nil when one is not a literal symbol.
+        def keyword_names(hash_node)
+          hash_node.elements.map do |element|
+            key = element.key
+            return nil unless key.is_a?(Prism::SymbolNode)
+
+            key.unescaped.to_sym
+          end
+        end
+
+        def takes?(method_type, positional, keywords, block)
+          function = method_type.type
+          # `(...) -> T`: an untyped parameter list takes every call.
+          return block_taken?(method_type.block, block) unless function.respond_to?(:required_positionals)
+
+          block_taken?(method_type.block, block) && arguments_taken?(function, positional, keywords)
+        end
+
+        def block_taken?(declared, block)
+          block ? !declared.nil? : (declared.nil? || !declared.required)
+        end
+
+        def arguments_taken?(function, positional, keywords)
+          return positional_taken?(function, positional) && function.required_keywords.empty? if keywords.nil?
+          # A keyword hash an overload declares no keywords for is its last positional argument.
+          return positional_taken?(function, positional + 1) unless keywords?(function)
+
+          positional_taken?(function, positional) && function.required_keywords.keys.all? do |key|
+            keywords.include?(key)
+          end
+        end
+
+        def positional_taken?(function, count)
+          required = function.required_positionals.size + function.trailing_positionals.size
+          return false if count < required
+
+          !function.rest_positionals.nil? || count <= required + function.optional_positionals.size
+        end
+
+        def keywords?(function)
+          !function.required_keywords.empty? || !function.optional_keywords.empty? || !function.rest_keywords.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/overload_selector.rb

@@ -10,6 +10,7 @@ require_relative "imprecise_argument"
 require_relative "keyword_arguments"
 require_relative "no_match_fallback"
 require_relative "proven_overload"
+require_relative "singleton_type_params"
 require_relative "receiver_affinity"
 require_relative "splat_arity"
 
@@ -53,6 +54,7 @@ module Rigor
       # The selector is intentionally agnostic about the dispatch kind (instance vs singleton). Both kinds
       # share the same arity and acceptance shape; the difference is only in which `Definition` the caller
       # fetched.
+      # rubocop:disable-next Metrics/ModuleLength -- the selection passes plus the #2828 overload rewrite wrapper.
       module OverloadSelector
         module_function
 
@@ -124,6 +126,16 @@ module Rigor
           declared = method_definition.method_types
           return [] if declared.empty?
 
+          # Issue #2828 — `singleton(T)` over a method type variable reads as a class object (`SingletonTypeParams`).
+          SingletonTypeParams.selecting(declared) do |overloads|
+            select_among(overloads, method_definition, arg_types, self_type, instance_type, type_vars, block_required,
+                         environment, member, keywords_last, splats, block_fallback)
+          end
+        end
+
+        # rubocop:disable-next Metrics/ParameterLists -- {.select_declared}'s inputs plus the overloads it reads.
+        def select_among(declared, method_definition, arg_types, self_type, instance_type, type_vars, block_required,
+                         environment, member, keywords_last, splats, block_fallback)
           # A keyword hash only some overload takes as keywords is a plain positional `Hash` otherwise (#1737).
           keywords_last &&= KeywordArguments.any_declares?(declared)