rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/precision_scanner.rb

@@ -122,13 +122,12 @@ module Rigor
         end
       end
 
-      # @param scope [Rigor::Scope] base scope for type inference.
+      # @param scope — base scope for type inference.
       def initialize(scope: nil)
         @scope = scope || Scope.empty
       end
 
-      # @param root [Prism::Node] the parsed AST
-      # @return [FileResult]
+      # @param root — the parsed AST
       def scan(root)
         scope_index = ScopeIndexer.index(root, default_scope: @scope)
         tier_counts = TIERS.to_h { |t| [t, 0] }
@@ -156,7 +155,7 @@ module Rigor
         when Type::Nominal, Type::Singleton,
              Type::DataClass, Type::StructClass then :nominal
         when Type::Tuple, Type::HashShape,
-             Type::IntegerRange, Type::App,
+             Type::IntegerRange, Type::FloatRange, Type::App,
              Type::DataInstance, Type::StructInstance,
              Type::BoundMethod                  then :shaped
         when Type::Refined                      then :refined

data/lib/rigor/inference/project_patched_methods.rb

@@ -28,7 +28,7 @@ module Rigor
 
       attr_reader :by_key
 
-      # @param entries [Array<Entry>] flat list of declarations observed during the pre-pass.
+      # @param entries — flat list of declarations observed during the pre-pass.
       #   First-write-wins on `(class_name, method_name, kind)` duplicates so the
       #   `pre-eval.duplicate-declaration` diagnostic emission stays decoupled from registry behaviour.
       def initialize(entries: [])
@@ -39,7 +39,7 @@ module Rigor
         freeze
       end
 
-      # @return [Entry, nil] the recorded entry for the given `(class_name, method_name, kind)` triple,
+      # @return the recorded entry for the given `(class_name, method_name, kind)` triple,
       #   or `nil` when no pre-eval file declared it.
       def lookup(class_name:, method_name:, kind:)
         @by_key[[class_name, method_name, kind]]

data/lib/rigor/inference/project_patched_scanner.rb

@@ -31,13 +31,13 @@ module Rigor
 
       module_function
 
-      # @param paths [Array<String>] absolute paths to the pre-eval files. The runner has already
+      # @param paths — absolute paths to the pre-eval files. The runner has already
       #   validated that each path exists (slice-1 `pre-eval.file-not-found` `:error` covers missing
       #   entries); the scanner does NOT re-check existence.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil] editor-mode buffer binding. When set, the
+      # @param buffer — editor-mode buffer binding. When set, the
       #   scanner reads the buffer's physical bytes if a pre-eval entry matches the logical path, so
       #   users editing a monkey-patch file see the in-flight version in their analysis.
-      # @return [Result] the populated registry plus any per-file warnings.
+      # @return the populated registry plus any per-file warnings.
       def scan(paths, buffer: nil)
         entries = []
         diagnostics = []

data/lib/rigor/inference/protection_scanner.rb

@@ -37,8 +37,7 @@ module Rigor
         @scope = scope || Scope.empty
       end
 
-      # @param root [Prism::Node] the parsed AST
-      # @return [FileResult]
+      # @param root — the parsed AST
       def scan(root)
         index = ScopeIndexer.index(root, default_scope: @scope)
         protected_count = 0

data/lib/rigor/inference/range_constant.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Reads the endpoints out of a `Constant<Range>`.
+    #
+    # A `Constant` normally carries a value and no generic instantiation, which is why acceptance
+    # ignores a nominal's `type_args` against one. A Range value is the exception: the engine only
+    # builds `Constant<Range>` when both endpoints are static (`ExpressionTyper#type_of_range`), so
+    # the element the range would yield IS known, and a `Range[T]` parameter can be judged against it.
+    #
+    # Two consumers share the reading so they cannot drift: `Acceptance` refutes a `Range[T]`
+    # parameter whose `T` rejects an endpoint (issue #833), and `RbsDispatch` binds a method-level
+    # `Range[A]` parameter's `A` from the endpoints (issue #834).
+    module RangeConstant
+      module_function
+
+      # The non-`nil` endpoints of the range `type` pins, or nil when there is nothing to read from.
+      #
+      # nil — meaning "no opinion, keep the answer you already had" — covers a carrier that is not a
+      # `Constant<Range>`, a range with no endpoint at all (`nil..nil` constrains nothing), and a
+      # range whose endpoints are not literals. The literal set is the one
+      # `ExpressionTyper#static_range_endpoint` pins; a value outside it reached the carrier by some
+      # other route and the caller has no lifting for it.
+      def literal_endpoints(type)
+        return nil unless type.is_a?(Type::Constant)
+
+        value = type.value
+        return nil unless value.is_a?(::Range)
+
+        endpoints = [value.begin, value.end].compact
+        return nil if endpoints.empty?
+        return nil unless endpoints.all? { |endpoint| literal_endpoint?(endpoint) }
+
+        endpoints
+      end
+
+      # The endpoints lifted to their own classes and unioned — the element type the range would
+      # yield. Lifting rather than pinning the values mirrors
+      # `ExpressionTyper#nominal_range_for_endpoints`: `1..9` yields Integers, not the two values 1
+      # and 9, so binding a `Range[A]` parameter's `A` to `Integer` states what the runtime can
+      # honour. Nil when {#literal_endpoints} has nothing to read.
+      def element_type(type)
+        endpoints = literal_endpoints(type)
+        return nil if endpoints.nil?
+
+        Type::Combinator.union(*endpoints.map { |endpoint| Type::Combinator.nominal_of(endpoint.class.name) })
+      end
+
+      def literal_endpoint?(value)
+        value.is_a?(::Integer) || value.is_a?(::Float) || value.is_a?(::String)
+      end
+    end
+  end
+end

data/lib/rigor/inference/rbs_type_translator.rb

@@ -100,17 +100,31 @@ module Rigor
       ALIAS_EXPANSION_LIMIT = 8
       private_constant :ALIAS_EXPANSION_LIMIT
 
+      # #775 — `TypeName#relative!` allocates a TypeName and a Namespace and `#to_s` joins the path: four
+      # objects per class-instance translation, ~380k of them on the lib self-check, for the same few
+      # hundred names. rbs compares a TypeName by namespace + name, so a value-keyed memo answers every
+      # repeat with one frozen String.
+      @relative_names = {}
+
+      # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion. Closed means no
+      # `self`, `instance` or type variable anywhere inside, so the caller's context cannot change the
+      # answer; at expansion depth 0 the budget cannot either. rbs compares types by value, so the memo
+      # is per distinct expansion, not per loader (a re-parsed identical alias hits), and the weak keys
+      # let an entry go with the loader whose memo held the expansion. `Rigor::Type::t` on the self-check
+      # is a 21-member union that was re-translated ~13k times, each time re-normalising the union from
+      # scratch; every repeat now shares one Union.
+      @closed_alias_translations = ObjectSpace::WeakKeyMap.new
+
       class << self
-        # @param rbs_type [RBS::Types::Bases::Base, RBS::Types::ClassInstance, ...]
-        # @param self_type [Rigor::Type, nil] substitute for `Bases::Self`.
-        # @param instance_type [Rigor::Type, nil] substitute for `Bases::Instance`. Defaults to `nil`,
+        # @param self_type — substitute for `Bases::Self`.
+        # @param instance_type — substitute for `Bases::Instance`. Defaults to `nil`,
         #   which degrades to Dynamic[Top].
-        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map for `Bases::Variable`. Keys
+        # @param type_vars — substitution map for `Bases::Variable`. Keys
         #   are the RBS variable names (e.g., `:Elem`); values are Rigor types that replace the
         #   variable. Variables that are not bound in the map degrade to Dynamic[Top].
-        # @param alias_expander [#expand_type_alias, nil] resolves `RBS::Types::Alias` one level out —
-        #   in practice the environment's `RbsLoader`. When nil, aliases degrade to Dynamic[Top].
-        # @return [Rigor::Type]
+        # @param alias_expander — anything answering `expand_type_alias`, which resolves `RBS::Types::Alias`
+        #   one level out — in practice the environment's `RbsLoader`. When nil, aliases degrade to
+        #   Dynamic[Top].
         def translate(rbs_type, self_type: nil, instance_type: nil, type_vars: EMPTY_TYPE_VARS,
                       alias_expander: nil)
           translate_in(rbs_type, Context.new(self_type, instance_type, type_vars, alias_expander, 0))
@@ -180,11 +194,17 @@ module Rigor
         # `Nominal["Array", [Nominal["Integer"]]]`. Variables inside the args participate in
         # substitution through the same `type_vars:` map.
         def translate_class_instance(rbs_type, context)
-          name = rbs_type.name.relative!.to_s
+          name = relative_name(rbs_type.name)
+          return Type::Combinator.nominal_of(name) if rbs_type.args.empty?
+
           translated_args = rbs_type.args.map { |arg| translate_in(arg, context) }
           Type::Combinator.nominal_of(name, type_args: translated_args)
         end
 
+        def relative_name(type_name)
+          @relative_names[type_name] ||= type_name.relative!.to_s.freeze
+        end
+
         # Preserves tuple precision through the boundary. Each positional element type is translated
         # recursively under the caller's substitution context, and the resulting list is wrapped in a
         # `Rigor::Type::Tuple`.
@@ -218,8 +238,7 @@ module Rigor
         # `singleton(Foo)` is the type of the constant `Foo` itself (the class object). With the
         # dedicated Singleton type, we map directly to `Singleton[Foo]`.
         def translate_class_singleton(rbs_type, _context)
-          name = rbs_type.name.relative!.to_s
-          Type::Combinator.singleton_of(name)
+          Type::Combinator.singleton_of(relative_name(rbs_type.name))
         end
 
         # #529 — sees through a type alias instead of reading `untyped`. `expand_type_alias` resolves
@@ -232,8 +251,27 @@ module Rigor
 
           expanded = expander.expand_type_alias(rbs_type)
           return Type::Combinator.untyped if expanded.nil?
+          # A nested expansion is translated under its parent's budget, and `rigor trace` records every
+          # union merge as it happens, so neither consults the memo.
+          return translate_in(expanded, context.deeper) unless context.alias_depth.zero? && !FlowTracer.active?
+
+          cached = @closed_alias_translations[expanded]
+          return cached if cached
+
+          translated = translate_in(expanded, context.deeper)
+          @closed_alias_translations[expanded] = translated if closed_type?(expanded)
+          translated
+        end
+
+        # True when nothing in `rbs_type`'s tree reads the translation context: no `self`, no `instance`,
+        # no type variable. Every rbs type answers `each_type` (the leaves through `EmptyEachType`).
+        def closed_type?(rbs_type)
+          case rbs_type
+          when RBS::Types::Bases::Self, RBS::Types::Bases::Instance, RBS::Types::Variable then return false
+          end
 
-          translate_in(expanded, context.deeper)
+          rbs_type.each_type { |inner| return false unless closed_type?(inner) }
+          true
         end
 
         # #529 — `A & B` reads as its first member that carries static evidence. Every value of the

data/lib/rigor/inference/receiver_alias.rb

@@ -30,9 +30,9 @@ module Rigor
 
       module_function
 
-      # @param node  [Prism::Node, nil] the receiver expression.
-      # @param depth [Integer] recursion depth, internal.
-      # @return [Array<Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode>] every variable
+      # @param node — the receiver expression.
+      # @param depth — recursion depth, internal.
+      # @return every variable
       #   read the expression can evaluate to; empty when it can evaluate to none.
       def candidates(node, depth = 0)
         return [] if node.nil? || depth > WALK_DEPTH_CAP

data/lib/rigor/inference/refinement_mutation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+require_relative "string_mutation"
+
+module Rigor
+  module Inference
+    # The empty-witness `Difference` arm of {MutationWidening} — `non-empty-array[T]`,
+    # `non-empty-hash[K, V]` and `non-empty-string`, the refinement carriers `empty?` / `any?`
+    # narrowing writes (ADR-47 §4-4).
+    #
+    # Two questions, which the seam used to answer as one. **What the receiver now holds** is the
+    # ordinary content join, and it applies to a refinement exactly as it applies to a `Tuple`:
+    # {MutationWidening} owns that algebra and passes it in. **Whether the receiver is still
+    # provably non-empty** is this module's own, and it is a property of the mutator alone.
+    #
+    # Answering both with "widen to the bare base" was ADR-56 WD2.9's deferred branch (issue #936):
+    # `if xs.any?; xs << "s"` read `Array[String]` for an array that holds a String too — a wrong
+    # type, not a wide one — and lost a witness an append cannot falsify.
+    module RefinementMutation
+      # Mutators that CANNOT leave a non-empty receiver empty. Whitelists rather than a table of
+      # emptiers: a name missing from these retracts the witness, which is the conservative answer
+      # every mutator got before. The listed ones either only add (`<< push …`) or only permute a
+      # fixed number of slots (`sort! map! …`); `replace`, `compact!`, `flatten!`, `uniq!` and every
+      # remover are deliberately absent, since each has an input that empties the receiver.
+      EMPTY_PRESERVING = {
+        "Array" => %i[
+          << push append prepend unshift concat insert
+          map! collect! sort! sort_by! reverse! rotate! shuffle!
+        ].to_set.freeze,
+        "Hash" => %i[[]= store merge! update transform_keys! transform_values!].to_set.freeze
+      }.freeze
+
+      module_function
+
+      # The widened binding for an empty-witness refinement about to be mutated by `method_name`,
+      # or `nil` when nothing applies — including the case where the answer would be the pre-state
+      # itself, which the seam's callers read as "no widening".
+      #
+      # The block receives the refinement's BASE and answers the base with the mutator's added
+      # content joined in, or a falsey value to decline (the mutator is not in that base's table).
+      # A String base is answered here instead: it carries no content parameter, so the only
+      # question it has is the witness one.
+      def widen(difference, method_name)
+        return nil unless difference.removes_empty_witness?
+
+        base = difference.base
+        joined = base.class_name == "String" ? string_base(base, method_name) : yield(base)
+        return nil unless joined
+
+        widened = preserves_witness?(base.class_name, method_name) ? refine(joined, difference) : joined
+        widened == difference ? nil : widened
+      end
+
+      # A `non-empty-string` survives every mutator that cannot empty the buffer, and those are
+      # exactly the ones {StringMutation} does not list as emptying — so this arm declines them
+      # and the refinement stands, rather than widening to `String` and dropping it.
+      def string_base(base, method_name)
+        StringMutation::EMPTYING_MUTATORS.include?(method_name) ? base : nil
+      end
+
+      def preserves_witness?(class_name, method_name)
+        table = EMPTY_PRESERVING[class_name]
+        !!table&.include?(method_name)
+      end
+
+      def refine(joined, difference)
+        Type::Combinator.difference(joined, difference.removed)
+      end
+    end
+  end
+end