rigortype 0.1.0 → 0.1.1

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

@@ -42,14 +42,45 @@ module Rigor
         }.freeze
         private_constant :NUMERIC_CONSTRUCTORS
 
+        # `Kernel#Integer(s)` predicate-aware refinement set
+        # (v0.1.1 Track 1 slice 2b). Both `decimal-int-string` and
+        # `numeric-string` describe digit-only ASCII strings, so
+        # `Integer(s)` is total over the carrier domain and the
+        # result is `>= 0`. The default `base: 10` invocation
+        # accepts the same shape `String#to_i` does for these
+        # predicates; the `Integer(s, base)` overload is left for
+        # a later slice.
+        INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int, :numeric].freeze
+        private_constant :INTEGER_REFINEMENT_PREDICATES
+
         def try_dispatch(receiver:, method_name:, args:)
           return nil if receiver.nil?
           return try_array(args) if method_name == :Array
           return try_numeric_constructor(method_name, args) if NUMERIC_CONSTRUCTORS.key?(method_name)
+          return try_integer_from_refinement(args) if method_name == :Integer
 
           nil
         end
 
+        # `Kernel#Integer(s)` over a `Refined[String, predicate]`
+        # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
+        # Mirrors the `String#to_i` projection in `ShapeDispatch`
+        # (v0.1.1 slice 2a) — the result is always
+        # `non-negative-int`. Returns nil for any other arg shape
+        # so the RBS tier handles the generic `Integer(arg)` case.
+        def try_integer_from_refinement(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Refined)
+
+          base = arg.base
+          return nil unless base.is_a?(Type::Nominal) && base.class_name == "String"
+          return nil unless INTEGER_REFINEMENT_PREDICATES.include?(arg.predicate_id)
+
+          Type::Combinator.non_negative_int
+        end
+
         def try_array(args)
           return nil if args.length != 1
 

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

@@ -52,7 +52,27 @@ module Rigor
 
         CONCAT_METHODS = %i[+ << concat].freeze
         FORMAT_METHODS = %i[format sprintf].freeze
-        private_constant :CONCAT_METHODS, :FORMAT_METHODS
+        # v0.1.1 Track 1 slice 5a — methods that, called with no
+        # arguments on a literal-bearing receiver, return a value
+        # that is also literal-bearing. `#strip` / `#lstrip` /
+        # `#rstrip` / `#chomp` (no-arg) / `#chop` strip a known
+        # subset of characters from the ends, so the survivors
+        # are always a substring of an already-literal value.
+        # `#scrub` (no-arg) replaces invalid bytes; a literal-string
+        # value comes from source code and is always valid UTF-8,
+        # so the result is identical to the receiver. None of
+        # these preserve `non-empty-string`-ness (e.g. `"   ".strip
+        # == ""`); the carrier collapses from `non-empty-literal-string`
+        # down to plain `literal-string`.
+        LITERAL_PRESERVING_METHODS = %i[strip lstrip rstrip chomp chop scrub].freeze
+        # v0.1.1 Track 1 slice 5c — width-padding methods. `center`
+        # / `ljust` / `rjust` take a `width` Integer plus an
+        # optional literal padding `String`. When the receiver
+        # and the (default or supplied) padding are both
+        # literal-bearing, the result is literal-bearing too.
+        WIDTH_PADDING_METHODS = %i[center ljust rjust].freeze
+        private_constant :CONCAT_METHODS, :FORMAT_METHODS,
+                         :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
 
         def try_dispatch(receiver:, method_name:, args:, **) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           return fold_array_join(receiver, args) if method_name == :join
@@ -61,6 +81,10 @@ module Rigor
           return nil unless Type::Combinator.literal_string_compatible?(receiver)
 
           return fold_string_percent(args) if method_name == :%
+          if args.empty?
+            return LITERAL_PRESERVING_METHODS.include?(method_name) ? Type::Combinator.literal_string : nil
+          end
+          return fold_width_pad(args) if WIDTH_PADDING_METHODS.include?(method_name)
           return nil unless args.size == 1
 
           if CONCAT_METHODS.include?(method_name)
@@ -70,6 +94,23 @@ module Rigor
           end
         end
 
+        # `String#center` / `#ljust` / `#rjust` — first argument is
+        # the target width (Integer-typed), optional second
+        # argument is the padding string (must be literal-bearing
+        # for the result to stay literal). The default padding
+        # (a space) is always literal so the no-second-arg form
+        # passes through. Width is allowed to be any Integer
+        # because Ruby's runtime accepts negative widths and
+        # widths smaller than the receiver's length without
+        # raising.
+        def fold_width_pad(args)
+          return nil unless [1, 2].include?(args.size)
+          return nil unless integer_typed?(args[0])
+          return nil if args.size == 2 && !Type::Combinator.literal_string_compatible?(args[1])
+
+          Type::Combinator.literal_string
+        end
+
         def fold_concat(arg_type)
           return nil unless Type::Combinator.literal_string_compatible?(arg_type)
 
@@ -165,7 +206,7 @@ module Rigor
         end
 
         private_class_method :fold_concat, :fold_repeat, :fold_array_join,
-                             :fold_format, :fold_string_percent,
+                             :fold_format, :fold_string_percent, :fold_width_pad,
                              :literal_or_constant?, :integer_typed?
       end
     end

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

@@ -122,10 +122,25 @@ module Rigor
           Type::Nominal => :dispatch_nominal_size,
           Type::Difference => :dispatch_difference,
           Type::Refined => :dispatch_refined,
-          Type::Intersection => :dispatch_intersection
+          Type::Intersection => :dispatch_intersection,
+          Type::IntegerRange => :dispatch_integer_range
         }.freeze
         private_constant :RECEIVER_HANDLERS
 
+        # v0.1.1 Track 1 slice 5b — `Integer#to_s(base)` on a
+        # non-negative `IntegerRange` receiver. The output of
+        # `n.to_s(b)` for `n >= 0` is digit-string-only (no
+        # leading sign), so when the base is in this table the
+        # result lifts to the matching imported refinement.
+        # Bases not listed (2, 36, ...) keep the v0.1.0 baseline
+        # since Rigor has no carrier for the resulting alphabet.
+        TO_S_BASE_REFINEMENTS = {
+          10 => :decimal_int_string,
+          8 => :octal_int_string,
+          16 => :hex_int_string
+        }.freeze
+        private_constant :TO_S_BASE_REFINEMENTS
+
         def try_dispatch(receiver:, method_name:, args:)
           args ||= []
           handler = RECEIVER_HANDLERS[receiver.class]
@@ -184,6 +199,42 @@ module Rigor
             Type::Combinator.non_negative_int
           end
 
+          # `IntegerRange#to_s` precision (v0.1.1 Track 1 slice 5b).
+          # When the range's lower bound is `>= 0`, every member is
+          # a non-negative integer and `to_s(base)` returns a
+          # digit-string with no leading sign. The result lifts to
+          # the matching imported refinement (`decimal-int-string`
+          # for base 10, `octal-int-string` for 8, `hex-int-string`
+          # for 16). Signed ranges fall through (the result could
+          # carry a `-` sign that no Rigor refinement currently
+          # captures), as do bases without a digit-only refinement.
+          def dispatch_integer_range(range, method_name, args)
+            return nil unless method_name == :to_s
+            return nil unless range.lower >= 0
+
+            base = base_argument(args)
+            return nil if base.nil?
+
+            refinement = TO_S_BASE_REFINEMENTS[base]
+            return nil if refinement.nil?
+
+            Type::Combinator.public_send(refinement)
+          end
+
+          # `to_s` with no argument defaults to base 10. With one
+          # argument, the value MUST be a `Constant<Integer>` to
+          # be statically known. Anything else (Nominal[Integer]
+          # arg, multi-arg, etc.) declines.
+          def base_argument(args)
+            return 10 if args.empty?
+            return nil unless args.size == 1
+
+            arg = args.first
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
+
+            arg.value
+          end
+
           # Refinement-aware projections over a `Difference[base,
           # removed]` receiver. When the removed value is the
           # empty witness of the base (`Constant[""]` for
@@ -289,7 +340,21 @@ module Rigor
             %i[octal_int downcase] => :refined_self,
             %i[octal_int upcase] => :refined_self,
             %i[hex_int downcase] => :refined_self,
-            %i[hex_int upcase] => :refined_self
+            %i[hex_int upcase] => :refined_self,
+            # v0.1.1 Track 1 slice 2 — `to_i` / `to_int` on a
+            # known digit-only string. `decimal-int-string`
+            # (`/\A\d+\z/`) and `numeric-string` (Rigor's
+            # numeric-string predicate, ASCII digits) are
+            # predicates over digit-only strings, so the parse
+            # is total over the carrier domain and the result
+            # is always `>= 0`. `non-negative-int` is the
+            # tightest carrier that captures both the lower
+            # bound and the integer-ness without inventing a
+            # narrower carrier.
+            %i[decimal_int to_i] => :non_negative_int,
+            %i[decimal_int to_int] => :non_negative_int,
+            %i[numeric to_i] => :non_negative_int,
+            %i[numeric to_int] => :non_negative_int
           }.freeze
           private_constant :REFINED_STRING_PROJECTIONS
 
@@ -313,6 +378,7 @@ module Rigor
             when :refined_self then refined
             when :uppercase_string then Type::Combinator.uppercase_string
             when :lowercase_string then Type::Combinator.lowercase_string
+            when :non_negative_int then Type::Combinator.non_negative_int
             end
           end
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -2,6 +2,8 @@
 
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../flow_contribution"
+require_relative "../flow_contribution/merger"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
@@ -59,12 +61,25 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, block_type: nil, environment: nil)
+      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/ParameterLists
+                   block_type: nil, environment: nil,
+                   call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
         precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
+        # v0.1.1 Track 2 slice 7 — plugin return-type contribution
+        # tier. Sits ahead of `RbsDispatch` so a plugin that
+        # understands a domain-specific dispatch (e.g. an
+        # `ActiveRecord::Base.find` returning `Nominal[<resolved
+        # model>]`) wins over the RBS-projected envelope. Only
+        # consults the registry when both `call_node` and `scope`
+        # are supplied — the dispatcher's own internal callers
+        # (per-element block fold, etc.) skip this tier.
+        plugin_result = try_plugin_contribution(call_node, scope)
+        return plugin_result if plugin_result
+
         rbs_result = RbsDispatch.try_dispatch(
           receiver: receiver_type, method_name: method_name, args: arg_types,
           environment: environment, block_type: block_type
@@ -85,6 +100,40 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
+      # slice 7. Walks every loaded plugin's
+      # `#flow_contribution_for(call_node:, scope:)` hook,
+      # collects the non-nil `FlowContribution` bundles, merges
+      # them through `FlowContribution::Merger`, and returns
+      # the merged `return_type` slot (or nil when no plugin
+      # contributed a return type).
+      #
+      # Plugins whose hook raises have their contribution
+      # silently dropped for this call so the dispatch chain
+      # keeps moving — the run-level diagnostic envelope (per
+      # ADR-2 § "Plugin Trust and I/O Policy") is owned by
+      # `Analysis::Runner#plugin_emitted_diagnostics`.
+      def try_plugin_contribution(call_node, scope)
+        return nil if call_node.nil? || scope.nil?
+
+        registry = scope.environment&.plugin_registry
+        return nil if registry.nil? || registry.empty?
+
+        contributions = collect_plugin_contributions(registry, call_node, scope)
+        return nil if contributions.empty?
+
+        FlowContribution::Merger.merge(contributions).return_type
+      end
+
+      def collect_plugin_contributions(registry, call_node, scope)
+        registry.plugins.filter_map do |plugin|
+          contribution = plugin.flow_contribution_for(call_node: call_node, scope: scope)
+          contribution.is_a?(FlowContribution) ? contribution : nil
+        rescue StandardError
+          nil
+        end
+      end
+
       # Runs the precision tiers (constant fold, shape dispatch,
       # file-path fold, block fold) in order and returns the first
       # non-nil answer. Each tier owns its own receiver/argument

data/lib/rigor/inference/narrowing.rb

@@ -7,6 +7,7 @@ require_relative "../type"
 require_relative "../environment"
 require_relative "../rbs_extended"
 require_relative "../analysis/fact_store"
+require_relative "../builtins/regex_refinement"
 
 module Rigor
   module Inference
@@ -746,20 +747,51 @@ module Rigor
         # `nil`. Subtract the dead half on each edge so callers
         # like `year.upcase` inside the truthy branch no longer
         # fire `possible-nil-receiver`.
+        #
+        # v0.1.1 Track 1 slice 1 — when the regex source is a
+        # statically known `RegularExpressionNode` and a named
+        # capture's body matches one of the curated shapes in
+        # {Rigor::Builtins::RegexRefinement::RULES}, the truthy
+        # branch narrows further than `String` to the matching
+        # imported refinement (e.g. `decimal-int-string` for
+        # `\d+`). Bodies outside the table fall back to the
+        # v0.1.0 baseline (plain `String`).
         def analyse_match_write(node, scope)
           string_t = Type::Combinator.nominal_of("String")
           nil_t = Type::Combinator.constant_of(nil)
+          refinements = match_write_capture_refinements(node)
           truthy = scope
           falsey = scope
           node.targets.each do |target|
             next unless target.is_a?(Prism::LocalVariableTargetNode)
 
-            truthy = truthy.with_local(target.name, string_t)
+            truthy = truthy.with_local(target.name, refinements[target.name] || string_t)
             falsey = falsey.with_local(target.name, nil_t)
           end
           [truthy, falsey]
         end
 
+        # Extracts `{ capture_name => Refinement }` for every named
+        # capture group in the `MatchWriteNode`'s wrapped `=~` call
+        # whose body the recogniser table accepts. Bodies that
+        # contain nested groups, anchors, alternation, or anything
+        # else outside the curated forms drop out and the caller
+        # falls back to plain `String`.
+        NAMED_CAPTURE_BODY_RE = /\(\?<([A-Za-z_][A-Za-z0-9_]*)>([^()|]*)\)/
+        private_constant :NAMED_CAPTURE_BODY_RE
+
+        def match_write_capture_refinements(node)
+          regex = node.call.is_a?(Prism::CallNode) ? node.call.receiver : nil
+          return {} unless regex.is_a?(Prism::RegularExpressionNode)
+
+          refinements = {}
+          regex.unescaped.scan(NAMED_CAPTURE_BODY_RE) do |name, body|
+            type = ::Rigor::Builtins::RegexRefinement.for_capture_body(body)
+            refinements[name.to_sym] = type if type
+          end
+          refinements
+        end
+
         # Recognised CallNode predicates:
         # - `recv.nil?` (Slice 6 phase 1, no args, no block)
         # - unary `!recv` (`name == :!`, no args, no block)
@@ -772,19 +804,82 @@ module Rigor
         # through to the no-narrowing fallback.
         def analyse_call(node, scope)
           return nil if node.block
-          return nil if node.receiver.nil?
 
-          shape_result = dispatch_call(node, scope, node.name)
-          return shape_result if shape_result
+          unless node.receiver.nil?
+            shape_result = dispatch_call(node, scope, node.name)
+            return shape_result if shape_result
+
+            # v0.1.1 Track 1 slice 4 — String predicate flow facts.
+            string_predicate_result = analyse_string_predicate(node, scope)
+            return string_predicate_result if string_predicate_result
+          end
 
           # Slice 7 phase 15 — RBS::Extended predicate
           # effects. When the method's RBS signature carries
           # `rigor:v1:predicate-if-true` / `predicate-if-false`
           # annotations, apply them to narrow the corresponding
-          # local-variable arguments on each edge.
+          # local-variable arguments on each edge. v0.1.1 Track
+          # 1 slice 3 — implicit-self calls (`recv == nil`,
+          # e.g. `admin?` inside an instance method body) flow
+          # through here too so `self`-targeted facts can edit
+          # `scope.self_type`.
           analyse_rbs_extended_contribution(node, scope)
         end
 
+        # v0.1.1 Track 1 slice 4 — `String#start_with?` /
+        # `#end_with?` / `#include?` against a `Constant<String>`
+        # needle attaches a relational `FactStore::Fact` to the
+        # local on each edge. The receiver's type does NOT
+        # change — Rigor has no "starts-with-X" carrier today —
+        # so the fact carries the predicate semantics for any
+        # downstream consumer that wants to read it (e.g. a
+        # plugin's `prepare(services)` hook in v0.1.x).
+        # Truthy edge: positive polarity. Falsey edge: negative
+        # polarity. Mirrors the equality-predicate fact pattern
+        # already used by `analyse_equality_predicate`.
+        STRING_PREDICATE_NAMES = %i[start_with? end_with? include?].freeze
+        private_constant :STRING_PREDICATE_NAMES
+
+        def analyse_string_predicate(node, scope)
+          return nil unless string_predicate_call?(node)
+
+          needle = string_predicate_needle(node, scope)
+          return nil if needle.nil?
+
+          local_name = node.receiver.name
+          return nil if scope.local(local_name).nil?
+
+          [
+            scope.with_fact(string_predicate_fact(local_name, node.name, needle, polarity: :positive)),
+            scope.with_fact(string_predicate_fact(local_name, node.name, needle, polarity: :negative))
+          ]
+        end
+
+        def string_predicate_call?(node)
+          STRING_PREDICATE_NAMES.include?(node.name) &&
+            node.receiver.is_a?(Prism::LocalVariableReadNode) &&
+            !node.arguments.nil? &&
+            node.arguments.arguments.size == 1
+        end
+
+        def string_predicate_needle(node, scope)
+          needle_type = static_literal_type(node.arguments.arguments.first, scope)
+          return nil unless needle_type.is_a?(Type::Constant) && needle_type.value.is_a?(String)
+
+          needle_type.value
+        end
+
+        def string_predicate_fact(name, predicate, needle, polarity:)
+          Analysis::FactStore::Fact.new(
+            bucket: :relational,
+            target: Analysis::FactStore::Target.local(name),
+            predicate: predicate,
+            payload: needle,
+            polarity: polarity,
+            stability: :local_binding
+          )
+        end
+
         ZERO_CLASS_PREDICATES = %i[positive? negative? zero? nonzero?].freeze
         COMPARISON_OPERATORS = %i[< <= > >=].freeze
         private_constant :ZERO_CLASS_PREDICATES, :COMPARISON_OPERATORS
@@ -1267,6 +1362,7 @@ module Rigor
 
         def apply_fact_to_scope(fact, call_node, entry_scope, target_scope, method_def)
           target_node = fact_target_node(fact, call_node, method_def)
+          return apply_self_fact(fact, target_node, entry_scope, target_scope) if fact.target_kind == :self
           return target_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
 
           local_name = target_node.name
@@ -1277,6 +1373,45 @@ module Rigor
           target_scope.with_local(local_name, narrowed)
         end
 
+        # v0.1.1 Track 1 slice 3 — `target_kind == :self` facts
+        # (`predicate-if-true self is T`, `predicate-if-false
+        # self is T`) narrow whichever scope binding is bound to
+        # the call's receiver. Four receiver shapes participate:
+        #
+        #   `recv.method?` where recv is...
+        #   - `LocalVariableReadNode`            -> narrow that local
+        #   - `InstanceVariableReadNode`         -> narrow that ivar
+        #   - `Prism::SelfNode` (explicit self)  -> narrow `self_type`
+        #   - nil (implicit self call inside a method body)
+        #                                        -> narrow `self_type`
+        #
+        # Other receiver shapes (method chains, expressions) have
+        # no scope binding to narrow against and fall through.
+        def apply_self_fact(fact, receiver_node, entry_scope, target_scope)
+          case receiver_node
+          when nil, Prism::SelfNode
+            current = entry_scope.self_type
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_self_type(narrowed)
+          when Prism::LocalVariableReadNode
+            current = entry_scope.local(receiver_node.name)
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_local(receiver_node.name, narrowed)
+          when Prism::InstanceVariableReadNode
+            current = entry_scope.ivar(receiver_node.name)
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_ivar(receiver_node.name, narrowed)
+          else
+            target_scope
+          end
+        end
+
         # Resolves a Fact's target node. Mirrors the earlier
         # `effect_target_node` helper but reads from the
         # canonical Fact carrier; `:self` routes to the call
@@ -1291,7 +1426,9 @@ module Rigor
         end
 
         def resolve_rbs_extended_method(node, scope)
-          receiver_type = scope.type_of(node.receiver)
+          receiver_type = receiver_type_for_resolve(node, scope)
+          return nil if receiver_type.nil?
+
           class_name = rbs_extended_class_name(receiver_type)
           return nil if class_name.nil?
           return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
@@ -1305,6 +1442,13 @@ module Rigor
           nil
         end
 
+        # Implicit self call (`admin?` with no receiver inside an
+        # instance method body) — read the method definition from
+        # `scope.self_type` per v0.1.1 Track 1 slice 3.
+        def receiver_type_for_resolve(node, scope)
+          node.receiver.nil? ? scope.self_type : scope.type_of(node.receiver)
+        end
+
         def rbs_extended_class_name(receiver_type)
           case receiver_type
           when Type::Nominal, Type::Singleton then receiver_type.class_name

data/lib/rigor/inference/scope_indexer.rb

@@ -552,7 +552,7 @@ module Rigor
         when Prism::ModuleNode, Prism::ClassNode
           return if record_class_or_module?(node, qualified_prefix, identity_table, discovered)
         when Prism::ConstantWriteNode
-          return if record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
+          return if record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
         end
 
         node.compact_child_nodes.each do |child|
@@ -573,17 +573,23 @@ module Rigor
         true
       end
 
-      # Recognises `Const = Data.define(*Symbol) [do ... end]` and registers
-      # `Const` (qualified by the surrounding class/module path) as a
-      # discovered class. `Const.new(...)` then resolves to a fresh
-      # `Nominal[Const]` via `meta_new`, instead of the un-narrowed
-      # `Dynamic[top]` returned by the default `Class#new` envelope.
+      # Recognises class-creating meta calls at constant-write rvalue
+      # position and registers `Const` (qualified by the surrounding
+      # class/module path) as a discovered class. `Const.new(...)`
+      # then resolves to a fresh `Nominal[Const]` via `meta_new`,
+      # instead of the un-narrowed `Dynamic[top]` returned by the
+      # default `Class#new` envelope.
       #
-      # The Data.define block body, if present, is recursed into so any
-      # nested class/module declarations in the override block (rare but
-      # legal) still feed the discovered table.
-      def record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
-        return false unless data_define_call?(node.value)
+      # Two recognised meta forms:
+      #
+      # - `Const = Data.define(*Symbol) [do ... end]`
+      # - `Const = Struct.new(*Symbol [, keyword_init: ...]) [do ... end]`
+      #
+      # The block body, if present, is recursed into so any nested
+      # class/module declarations in the override block (rare but legal)
+      # still feed the discovered table.
+      def record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
+        return false unless data_define_call?(node.value) || struct_new_call?(node.value)
 
         full = (qualified_prefix + [node.name.to_s]).join("::")
         discovered[full] = Type::Combinator.singleton_of(full)
@@ -599,18 +605,46 @@ module Rigor
       def data_define_call?(node)
         return false unless node.is_a?(Prism::CallNode)
         return false unless node.name == :define
-        return false unless data_constant_receiver?(node.receiver)
+        return false unless meta_constant_receiver?(node.receiver, :Data)
 
         args = node.arguments&.arguments || []
         args.all?(Prism::SymbolNode)
       end
 
-      def data_constant_receiver?(node)
+      # Recognises `Struct.new(*Symbol)` and
+      # `Struct.new(*Symbol, keyword_init: <expr>)` at constant-write
+      # rvalue position. A trailing `KeywordHashNode` (the
+      # `keyword_init: ...` form) is accepted but does not contribute
+      # to member discovery; every other argument MUST be a
+      # `Prism::SymbolNode`. At least one Symbol member is required —
+      # `Struct.new()` is a degenerate form callers don't typically use.
+      def struct_new_call?(node)
+        return false unless meta_call_with_name?(node, :Struct, :new)
+
+        args = node.arguments&.arguments || []
+        positional = struct_new_positionals(args)
+        return false if positional.nil? || positional.empty?
+
+        positional.all?(Prism::SymbolNode)
+      end
+
+      def meta_call_with_name?(node, receiver_name, method_name)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless node.name == method_name
+
+        meta_constant_receiver?(node.receiver, receiver_name)
+      end
+
+      def struct_new_positionals(args)
+        args.last.is_a?(Prism::KeywordHashNode) ? args[0..-2] : args
+      end
+
+      def meta_constant_receiver?(node, expected_name)
         case node
         when Prism::ConstantReadNode
-          node.name == :Data
+          node.name == expected_name
         when Prism::ConstantPathNode
-          node.parent.nil? && node.name == :Data
+          node.parent.nil? && node.name == expected_name
         end
       end
 

data/lib/rigor/inference/statement_evaluator.rb

@@ -1015,6 +1015,7 @@ module Rigor
       # same hierarchy-aware narrowing rules.
       def apply_post_return_fact(fact, call_node, current_scope, method_def)
         target_node = fact_target_node(fact, call_node, method_def)
+        return apply_self_post_return_fact(fact, target_node, current_scope) if fact.target_kind == :self
         return current_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
 
         local_name = target_node.name
@@ -1025,6 +1026,34 @@ module Rigor
         current_scope.with_local(local_name, narrowed)
       end
 
+      # v0.1.1 Track 1 slice 3 — `assert self is T` post-return
+      # narrowing for the four supported receiver shapes (mirrors
+      # `Narrowing#apply_self_fact`).
+      def apply_self_post_return_fact(fact, receiver_node, current_scope)
+        case receiver_node
+        when nil, Prism::SelfNode
+          current = current_scope.self_type
+          return current_scope if current.nil?
+
+          narrowed = Narrowing.narrow_for_fact(current, fact, current_scope.environment)
+          current_scope.with_self_type(narrowed)
+        when Prism::LocalVariableReadNode
+          current = current_scope.local(receiver_node.name)
+          return current_scope if current.nil?
+
+          narrowed = Narrowing.narrow_for_fact(current, fact, current_scope.environment)
+          current_scope.with_local(receiver_node.name, narrowed)
+        when Prism::InstanceVariableReadNode
+          current = current_scope.ivar(receiver_node.name)
+          return current_scope if current.nil?
+
+          narrowed = Narrowing.narrow_for_fact(current, fact, current_scope.environment)
+          current_scope.with_ivar(receiver_node.name, narrowed)
+        else
+          current_scope
+        end
+      end
+
       # `:self` routes to the call receiver; otherwise we look
       # up the matching positional argument by parameter name.
       def fact_target_node(fact, call_node, method_def)