rigortype 0.1.4 → 0.1.5

data/lib/rigor/inference/method_dispatcher.rb

@@ -97,6 +97,20 @@ module Rigor
           return rbs_result
         end
 
+        # ADR-16 Tier B / Tier C — synthetic-method tier. Sits
+        # BELOW RBS dispatch (per WD13: user-authored RBS overrides
+        # substrate synthesis) and ABOVE the dependency-source
+        # inference tier so a plugin's declared emit table beats
+        # the generic gem-source fallback for the same class. Slice
+        # 6a-TierB (origin_module dispatch) lands precise return
+        # types for Tier B emissions; Tier C emissions still return
+        # `Dynamic[T]` at this tier (slice 6b is the Tier C
+        # promotion via ADR-13's resolver chain).
+        synthetic_result = try_synthetic_method(
+          receiver_type, method_name, arg_types, block_type, environment
+        )
+        return synthetic_result if synthetic_result
+
         # ADR-10 slice 2b-ii — dependency-source inference tier.
         # Sits BELOW RBS dispatch (RBS / RBS::Inline / generated
         # stubs / plugin contracts always win) and ABOVE the
@@ -225,6 +239,101 @@ module Rigor
       # publish as ground-truth `T`). Returns `nil` when the
       # environment carries no index, the index has no entry, or
       # the receiver has no nominal class to look up.
+      # ADR-16 synthetic-method tier. Slice 2b shipped the floor —
+      # a match short-circuits at the right precedence (above
+      # dep-source / discovered / user-class-fallback; below RBS)
+      # and returns `Dynamic[T]`. Slice 6 (precision promotion):
+      # - Tier B path (slice 6a, `provenance[:origin_module]`
+      #   recorded by the slice-3b scanner): redispatch on
+      #   `Nominal[origin_module]` via `RbsDispatch` so the
+      #   module's authored RBS return type wins. Devise's
+      #   `valid_password?` returns `bool`, not `Dynamic[T]`.
+      # - Tier C path (slice 6b, plain `return_type:` string from
+      #   the manifest's emit table): look up
+      #   `environment.nominal_for_name(return_type)` so
+      #   `attribute :avatar, Types::String` emits a synthetic
+      #   reader returning `Nominal[ActiveStorage::Attached::One]`
+      #   (when the class is in RBS). Unparameterised class names
+      #   only — parameterised forms (`Array[String]`,
+      #   `Hash[K, V]`) and plugin-supplied utility-type names
+      #   (`Pick<T, K>`) require routing through the full ADR-13
+      #   `Plugin::TypeNodeResolver` chain, which slice 6 does
+      #   not yet wire in (the resolver chain is consulted only
+      #   for `%a{rigor:v1:…}` payloads as of ADR-13 slice 3).
+      def try_synthetic_method(receiver_type, method_name, arg_types, block_type, environment)
+        index = environment&.synthetic_method_index
+        return nil if index.nil? || index.empty?
+
+        class_name = synthetic_method_class_name(receiver_type)
+        return nil if class_name.nil?
+
+        matches = case receiver_type
+                  when Type::Singleton then index.lookup_singleton(class_name, method_name)
+                  else index.lookup_instance(class_name, method_name)
+                  end
+        return nil if matches.empty?
+
+        promoted = promote_synthetic_match(matches, method_name, arg_types, block_type, environment)
+        promoted || Type::Combinator.untyped
+      end
+
+      # First non-nil promotion wins. Tier B (origin_module) and
+      # Tier C (return_type nominal lookup) are tried in the
+      # same registration-order pass per WD11 first-wins —
+      # the slice-3b scanner sets `origin_module` for Tier B
+      # entries and leaves it absent for Tier C, so the two
+      # paths self-route per match.
+      def promote_synthetic_match(matches, method_name, arg_types, block_type, environment)
+        return nil if environment.nil?
+
+        matches.each do |synthetic|
+          promoted =
+            promote_via_origin_module(synthetic, method_name, arg_types, block_type, environment) ||
+            promote_via_return_type(synthetic, environment)
+          return promoted if promoted
+        end
+        nil
+      end
+
+      # Slice 6a-TierB. For Tier B emissions (origin_module
+      # recorded in provenance), redispatch the call on the
+      # included module's `Nominal[...]` type via `RbsDispatch`.
+      # Returns nil when the SyntheticMethod is not a Tier B
+      # entry or when the origin_module is not in the RBS env.
+      def promote_via_origin_module(synthetic, method_name, arg_types, block_type, environment)
+        module_name = synthetic.provenance[:origin_module]
+        return nil unless module_name
+
+        module_type = Type::Combinator.nominal_of(module_name)
+        RbsDispatch.try_dispatch(
+          receiver: module_type, method_name: method_name, args: arg_types,
+          environment: environment, block_type: block_type
+        )
+      end
+
+      # Slice 6b-TierC. For Tier C emissions, look up the
+      # manifest-declared `return_type:` string via
+      # `environment.nominal_for_name`. Skips the placeholder
+      # `"untyped"` (Tier B's record-but-do-not-resolve marker
+      # from the slice-3b scanner) and the `"void"` keyword
+      # (RBS-style absent return). Falls back to nil when the
+      # class is not in the env — caller then returns Dynamic[T].
+      TIER_C_PLACEHOLDER_RETURNS = %w[untyped void].freeze
+      private_constant :TIER_C_PLACEHOLDER_RETURNS
+
+      def promote_via_return_type(synthetic, environment)
+        return_type = synthetic.return_type
+        return nil if return_type.nil? || TIER_C_PLACEHOLDER_RETURNS.include?(return_type)
+
+        environment.nominal_for_name(return_type)
+      end
+
+      def synthetic_method_class_name(receiver_type)
+        case receiver_type
+        when Type::Nominal, Type::Singleton then receiver_type.class_name
+        end
+      end
+
       def try_dependency_source(receiver_type, method_name, environment)
         index = environment&.dependency_source_index
         return nil if index.nil? || index.empty?
@@ -469,9 +578,25 @@ module Rigor
         Type::Combinator.nominal_of(receiver_type.class_name)
       end
 
-      CONSTANT_CONSTRUCTORS = {
-        "Pathname" => ->(arg) { Pathname.new(arg) }
-      }.freeze
+      # ADR-15 Phase 4b.x — `Ractor.make_shareable` on both the
+      # outer Hash and each lambda value. A plain `.freeze` leaves
+      # the Procs unshareable; reading `CONSTANT_CONSTRUCTORS[class]`
+      # from a worker Ractor would raise `Ractor::IsolationError`,
+      # which the `rescue StandardError` in
+      # `constant_constructor_lift` silently swallows — `meta_new`
+      # then falls back to `Nominal[Pathname]` in pool mode while
+      # sequential builds the `Constant<Pathname>` lift. The
+      # divergence surfaces downstream as a spurious
+      # `call.argument-type-mismatch` (sequential's
+      # `argument_type_diagnostic` short-circuits on Constant<Pathname>
+      # because Pathname is not in its CONSTANT_CLASSES table; pool's
+      # Nominal[Pathname] doesn't short-circuit). Surfaced on GitLab
+      # FOSS via `lib/gitlab/mail_room.rb:17`.
+      CONSTANT_CONSTRUCTORS = Ractor.make_shareable({
+                                                      "Pathname" => Ractor.make_shareable(lambda { |arg|
+                                                                                            Pathname.new(arg)
+                                                                                          })
+                                                    })
       private_constant :CONSTANT_CONSTRUCTORS
 
       def constant_constructor_lift(class_name, arg_types)

data/lib/rigor/inference/method_parameter_binder.rb

@@ -211,20 +211,30 @@ module Rigor
       # (`?by:`) while the Ruby `def` lists it as required (or vice
       # versa); the binding is by-name regardless of which side
       # defines it.
-      KEYWORD_PROVIDER = lambda do |fn, slot|
+      KEYWORD_PROVIDER = Ractor.make_shareable(lambda do |fn, slot|
         fn.required_keywords[slot.name]&.type || fn.optional_keywords[slot.name]&.type
-      end
+      end)
       private_constant :KEYWORD_PROVIDER
 
-      RBS_TYPE_PROVIDERS = {
-        required_positional: ->(fn, slot) { fn.required_positionals[slot.index]&.type },
-        optional_positional: ->(fn, slot) { fn.optional_positionals[slot.index]&.type },
-        rest_positional: ->(fn, _slot) { fn.rest_positionals&.type },
-        trailing_positional: ->(fn, slot) { fn.trailing_positionals[slot.index]&.type },
-        required_keyword: KEYWORD_PROVIDER,
-        optional_keyword: KEYWORD_PROVIDER,
-        rest_keyword: ->(fn, _slot) { fn.rest_keywords&.type }
-      }.freeze
+      RBS_TYPE_PROVIDERS = Ractor.make_shareable({
+                                                   required_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.required_positionals[slot.index]&.type
+                                                   }),
+                                                   optional_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.optional_positionals[slot.index]&.type
+                                                   }),
+                                                   rest_positional: Ractor.make_shareable(lambda { |fn, _slot|
+                                                     fn.rest_positionals&.type
+                                                   }),
+                                                   trailing_positional: Ractor.make_shareable(lambda { |fn, slot|
+                                                     fn.trailing_positionals[slot.index]&.type
+                                                   }),
+                                                   required_keyword: KEYWORD_PROVIDER,
+                                                   optional_keyword: KEYWORD_PROVIDER,
+                                                   rest_keyword: Ractor.make_shareable(lambda { |fn, _slot|
+                                                     fn.rest_keywords&.type
+                                                   })
+                                                 })
       private_constant :RBS_TYPE_PROVIDERS
 
       def rbs_type_for_slot(function, slot)

data/lib/rigor/inference/narrowing.rb

@@ -384,6 +384,14 @@ module Rigor
           analyse_statements(node, scope)
         when Prism::LocalVariableReadNode
           analyse_local_read(node, scope)
+        when Prism::LocalVariableWriteNode
+          analyse_local_write(node, scope)
+        when Prism::InstanceVariableWriteNode
+          analyse_ivar_write(node, scope)
+        when Prism::ClassVariableWriteNode
+          analyse_cvar_write(node, scope)
+        when Prism::GlobalVariableWriteNode
+          analyse_global_write(node, scope)
         when Prism::CallNode
           analyse_call(node, scope)
         when Prism::AndNode
@@ -736,6 +744,59 @@ module Rigor
           ]
         end
 
+        # Assignment-in-condition: `if name = expr` and the more
+        # frequent `if cond && (name = expr)` / `if cond && name =
+        # expr` Redmine-style guard. By the time narrowing runs,
+        # `StatementEvaluator#eval_local_write` has already bound
+        # the assigned local in `scope` to the rvalue type. The
+        # write's own truthiness IS the assigned value's
+        # truthiness, so the truthy edge narrows the local by
+        # `narrow_truthy(current)` and the falsey edge by
+        # `narrow_falsey(current)`. Mirrors `analyse_local_read`
+        # because the only meaningful difference between
+        # "predicate is `var`" and "predicate is `var = expr`" is
+        # which scope holds the just-bound value; the narrowing
+        # contract on the surrounding `if` is the same.
+        def analyse_local_write(node, scope)
+          current = scope.local(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_local(node.name, narrow_truthy(current)),
+            scope.with_local(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_ivar_write(node, scope)
+          current = scope.ivar(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_ivar(node.name, narrow_truthy(current)),
+            scope.with_ivar(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_cvar_write(node, scope)
+          current = scope.cvar(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_cvar(node.name, narrow_truthy(current)),
+            scope.with_cvar(node.name, narrow_falsey(current))
+          ]
+        end
+
+        def analyse_global_write(node, scope)
+          current = scope.global(node.name)
+          return nil if current.nil?
+
+          [
+            scope.with_global(node.name, narrow_truthy(current)),
+            scope.with_global(node.name, narrow_falsey(current))
+          ]
+        end
+
         # `if /(?<x>...)/ =~ str` — Prism wraps the `=~` call in a
         # `MatchWriteNode` listing the named-capture targets. The
         # parent `eval_match_write` has already bound each target
@@ -916,12 +977,12 @@ module Rigor
         # zero-arg predicates on `Numeric`. We model them as
         # comparisons against the literal 0 so the existing range
         # narrowing handles them uniformly.
-        ZERO_CLASS_PREDICATE_RULES = {
-          positive?: { truthy: [:>, 0],  falsey: [:<=, 0] },
-          negative?: { truthy: [:<, 0],  falsey: [:>=, 0] },
-          zero?: { truthy: [:eq, 0], falsey: [:ne, 0] },
-          nonzero?: { truthy: [:ne, 0], falsey: [:eq, 0] }
-        }.freeze
+        ZERO_CLASS_PREDICATE_RULES = Ractor.make_shareable({
+                                                             positive?: { truthy: [:>, 0], falsey: [:<=, 0] },
+                                                             negative?: { truthy: [:<, 0], falsey: [:>=, 0] },
+                                                             zero?: { truthy: [:eq, 0], falsey: [:ne, 0] },
+                                                             nonzero?: { truthy: [:ne, 0], falsey: [:eq, 0] }
+                                                           })
         private_constant :ZERO_CLASS_PREDICATE_RULES
 
         def analyse_zero_class_predicate(node, scope, predicate:)
@@ -1202,15 +1263,73 @@ module Rigor
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
-          class_name = static_class_name(node.arguments.arguments.first)
-          return nil if class_name.nil?
+          bare_name = static_class_name(node.arguments.arguments.first)
+          return nil if bare_name.nil?
 
           current = scope.local(node.receiver.name)
           return nil if current.nil?
 
+          # Resolve `bare_name` through the lexical-scope chain
+          # so a name shadowed by the current class / enclosing
+          # module wins over the top-level constant. Mirrors
+          # Ruby's `Module.nesting`-driven constant lookup. The
+          # canonical motivating case: inside
+          # `Rigor::Type::Singleton#==`, `is_a?(Singleton)`
+          # should resolve to `Rigor::Type::Singleton`, not the
+          # top-level stdlib `Singleton` mixin (which would
+          # surface as a spurious `undefined-method` on
+          # subsequent `other.class_name` calls).
+          class_name = resolve_class_name_lexically(bare_name, scope)
           class_predicate_scopes(scope, node.receiver.name, current, class_name, exact: exact)
         end
 
+        # Walks the lexical-nesting chain derived from
+        # `scope.self_type` and returns the first
+        # `<prefix>::<bare_name>` (or bare `<bare_name>` at the
+        # top level) that the environment recognises. Falls back
+        # to `bare_name` itself when nothing in the chain
+        # resolves; the downstream `narrow_class` then yields
+        # the conservative answer for unknown receivers.
+        def resolve_class_name_lexically(bare_name, scope)
+          return bare_name if bare_name.include?("::") # Already qualified.
+
+          chain = lexical_nesting_for(scope)
+          chain.each do |prefix|
+            candidate = "#{prefix}::#{bare_name}"
+            return candidate if class_known_to_scope?(scope, candidate)
+          end
+          bare_name
+        end
+
+        # Combines the environment's RBS-known set with the
+        # scope's in-source `discovered_classes` table so a
+        # lexical-nesting candidate matches a class the project
+        # declares but has no RBS for.
+        def class_known_to_scope?(scope, candidate)
+          return true if scope.environment.class_known?(candidate)
+
+          scope.discovered_classes.key?(candidate)
+        end
+
+        # Approximates `Module.nesting` from the inferable
+        # `self_type`. Today's implementation handles the common
+        # case: when the surrounding method is a regular
+        # instance method (`self_type = Nominal[T]`) or a
+        # class-body / singleton (`self_type = Singleton[T]`),
+        # the chain is `T`'s namespace path — `Foo::Bar::Baz`
+        # → `["Foo::Bar::Baz", "Foo::Bar", "Foo"]`. Returns an
+        # empty array when `self_type` is unknown.
+        def lexical_nesting_for(scope)
+          self_type = scope.self_type
+          base = case self_type
+                 when Type::Nominal, Type::Singleton then self_type.class_name
+                 end
+          return [] if base.nil? || base.empty?
+
+          parts = base.split("::")
+          parts.each_index.map { |i| parts[0..-(i + 1)].join("::") }
+        end
+
         def class_predicate_scopes(scope, name, current, class_name, exact:)
           [
             scope.with_local(

data/lib/rigor/inference/synthetic_method.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # ADR-16 Tier C output — one synthetic method declared by a
+    # plugin's `Plugin::Macro::HeredocTemplate` entry, after the
+    # pre-pass has interpolated the call-site literal symbol into
+    # the template name. Stored in {SyntheticMethodIndex} and
+    # consulted by {MethodDispatcher} below the RBS dispatch tier.
+    #
+    # Per ADR-16 § WD13 (cost-bounded best-effort): the v0.1.x
+    # delivery commitment is the floor — method names emit; their
+    # return types degrade to `Dynamic[T]` until slice 6
+    # (precision promotion) routes the recorded `return_type`
+    # string through ADR-13's `Plugin::TypeNodeResolver` chain.
+    # The string is preserved so the ceiling slice can resolve it
+    # without re-walking.
+    #
+    # The `provenance` Hash carries debug / `--explain` metadata:
+    # plugin id, the template's call shape, and the source
+    # location of the originating DSL call. Surfaced through the
+    # dispatcher's `macro.tier_c.*` provenance markers.
+    class SyntheticMethod
+      INSTANCE = :instance
+      SINGLETON = :singleton
+      VALID_KINDS = [INSTANCE, SINGLETON].freeze
+
+      attr_reader :class_name, :method_name, :return_type, :kind, :provenance
+
+      def initialize(class_name:, method_name:, return_type:, kind: INSTANCE, provenance: {})
+        validate!(class_name, method_name, return_type, kind, provenance)
+        @class_name = class_name.dup.freeze
+        @method_name = method_name.to_sym
+        @return_type = return_type.dup.freeze
+        @kind = kind
+        @provenance = provenance.transform_keys(&:to_sym).transform_values do |v|
+          v.is_a?(String) ? v.dup.freeze : v
+        end.freeze
+        freeze
+      end
+
+      def instance? = kind == INSTANCE
+      def singleton? = kind == SINGLETON
+
+      def to_h
+        {
+          "class_name" => class_name,
+          "method_name" => method_name.to_s,
+          "return_type" => return_type,
+          "kind" => kind.to_s,
+          "provenance" => provenance.transform_keys(&:to_s)
+        }
+      end
+
+      def ==(other)
+        other.is_a?(SyntheticMethod) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+
+      private
+
+      def validate!(class_name, method_name, return_type, kind, provenance)
+        unless class_name.is_a?(String) && !class_name.empty?
+          raise ArgumentError, "SyntheticMethod#class_name must be non-empty String, got #{class_name.inspect}"
+        end
+        unless method_name.is_a?(Symbol) || (method_name.is_a?(String) && !method_name.empty?)
+          raise ArgumentError, "SyntheticMethod#method_name must be Symbol/non-empty String, got #{method_name.inspect}"
+        end
+        unless return_type.is_a?(String) && !return_type.empty?
+          raise ArgumentError, "SyntheticMethod#return_type must be non-empty String, got #{return_type.inspect}"
+        end
+        unless VALID_KINDS.include?(kind)
+          raise ArgumentError, "SyntheticMethod#kind must be one of #{VALID_KINDS.inspect}, got #{kind.inspect}"
+        end
+
+        return if provenance.is_a?(Hash)
+
+        raise ArgumentError, "SyntheticMethod#provenance must be a Hash, got #{provenance.inspect}"
+      end
+    end
+  end
+end

data/lib/rigor/inference/synthetic_method_index.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "synthetic_method"
+
+module Rigor
+  module Inference
+    # Frozen, Ractor-shareable lookup table for the synthetic
+    # methods emitted by ADR-16 Tier C declarations during a
+    # single `Analysis::Runner#run`. Constructed by the pre-pass
+    # scanner (see {SyntheticMethodScanner}) and consulted by
+    # {MethodDispatcher} below `RbsDispatch.try_dispatch` (per WD13:
+    # user-authored RBS overrides substrate synthesis).
+    #
+    # The index is keyed by `(class_name, method_name, kind)`. A
+    # single key may resolve to multiple {SyntheticMethod} records
+    # if two plugins emit the same name (e.g. `rigor-dry-struct`
+    # and a hypothetical `rigor-dry-struct-extras` both registering
+    # the same attribute). Per ADR-16 WD11 / the WD-discussion in
+    # `## Open questions` the dispatcher uses first-wins by
+    # registration order; this index preserves that order in
+    # `lookup`'s return.
+    #
+    # ## Slice 2b — return-type precision posture
+    #
+    # The recorded `SyntheticMethod#return_type` is a String
+    # (e.g. `"ActiveStorage::Attached::One"`), preserved verbatim
+    # from the manifest's emit table. Slice 2b's engine wiring
+    # treats every match as returning `Dynamic[T]` per WD13's
+    # floor — the recorded string is the input to a later slice's
+    # precision promotion via ADR-13's `Plugin::TypeNodeResolver`.
+    class SyntheticMethodIndex
+      attr_reader :entries
+
+      def initialize(entries: [])
+        unless entries.is_a?(Array) && entries.all?(SyntheticMethod)
+          raise ArgumentError,
+                "SyntheticMethodIndex#entries must be an Array of SyntheticMethod, got #{entries.inspect}"
+        end
+
+        @entries = Ractor.make_shareable(entries.dup)
+        @by_instance = Ractor.make_shareable(bucket(entries, SyntheticMethod::INSTANCE))
+        @by_singleton = Ractor.make_shareable(bucket(entries, SyntheticMethod::SINGLETON))
+        freeze
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      # Returns an Array of matching {SyntheticMethod} records in
+      # plugin-registration order. Empty Array when no plugin has
+      # declared a Tier C entry that interpolates to this name.
+      def lookup_instance(class_name, method_name)
+        @by_instance.fetch([class_name, method_name.to_sym], EMPTY_ROW)
+      end
+
+      def lookup_singleton(class_name, method_name)
+        @by_singleton.fetch([class_name, method_name.to_sym], EMPTY_ROW)
+      end
+
+      def to_h
+        { "entries" => entries.map(&:to_h) }
+      end
+
+      EMPTY_ROW = [].freeze
+
+      def bucket(entries, kind)
+        h = {}
+        entries.each do |entry|
+          next unless entry.kind == kind
+
+          key = [entry.class_name, entry.method_name]
+          (h[key] ||= []) << entry
+        end
+        h.each_value(&:freeze).freeze
+      end
+      private :bucket
+
+      EMPTY = new(entries: []).freeze
+    end
+  end
+end