rigortype 0.0.2 → 0.0.4

data/lib/rigor/inference/statement_evaluator.rb

@@ -335,7 +335,17 @@ module Rigor
       # nil-injection on half-bound names so a name set in one branch
       # but not the other is observable as `T | nil` after the if.
       def eval_if(node)
-        _pred_type, post_pred = sub_eval(node.predicate, scope)
+        pred_type, post_pred = sub_eval(node.predicate, scope)
+
+        # When the predicate is a known-truthy / known-falsey type
+        # (notably `Constant[true]` / `Constant[false]` after the
+        # constant-fold tier), only the live branch contributes a
+        # type and a post-scope. The dead branch is skipped so the
+        # result type is precise (`Constant[:even]` instead of the
+        # joined `Constant[:even] | Constant[:odd]`).
+        live = live_branch_for_if(node, pred_type, post_pred)
+        return live if live
+
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, truthy_scope)
         else_type, else_scope = eval_branch_or_nil(node.subsequent, falsey_scope)
@@ -360,7 +370,11 @@ module Rigor
       # narrower's truthy/falsey edges are routed in swapped form
       # because `unless` runs its body when the predicate is falsey.
       def eval_unless(node)
-        _pred_type, post_pred = sub_eval(node.predicate, scope)
+        pred_type, post_pred = sub_eval(node.predicate, scope)
+
+        live = live_branch_for_unless(node, pred_type, post_pred)
+        return live if live
+
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, falsey_scope)
         else_type, else_scope = eval_branch_or_nil(node.else_clause, truthy_scope)
@@ -378,6 +392,38 @@ module Rigor
         ]
       end
 
+      # Returns the `[type, post_scope]` of the live branch when the
+      # predicate is provably truthy / falsey, else nil so the
+      # caller falls through to the standard both-branch evaluation.
+      # Constant `true`/`false` is the obvious trigger; non-falsey
+      # carriers like `Nominal[Integer]` (Integer is always truthy
+      # in Ruby — including 0) also collapse the dead else.
+      def live_branch_for_if(node, pred_type, post_pred)
+        case predicate_certainty(pred_type)
+        when :always_truthy then eval_branch_or_nil(node.statements, post_pred)
+        when :always_falsey then eval_branch_or_nil(node.subsequent, post_pred)
+        end
+      end
+
+      def live_branch_for_unless(node, pred_type, post_pred)
+        case predicate_certainty(pred_type)
+        when :always_truthy then eval_branch_or_nil(node.else_clause, post_pred)
+        when :always_falsey then eval_branch_or_nil(node.statements, post_pred)
+        end
+      end
+
+      def predicate_certainty(pred_type)
+        return nil if pred_type.nil? || pred_type.is_a?(Type::Bot)
+
+        truthy_bot = Narrowing.narrow_truthy(pred_type).is_a?(Type::Bot)
+        falsey_bot = Narrowing.narrow_falsey(pred_type).is_a?(Type::Bot)
+
+        return :always_falsey if truthy_bot && !falsey_bot
+        return :always_truthy if !truthy_bot && falsey_bot
+
+        nil
+      end
+
       def eval_else(node)
         return [Type::Combinator.constant_of(nil), scope] if node.statements.nil?
 
@@ -606,9 +652,172 @@ module Rigor
         evaluate_block_if_present(node)
         post_scope = record_closure_escape_if_any(node)
         post_scope = apply_rbs_extended_assertions(node, post_scope)
+        post_scope = apply_rspec_matcher_narrowing(node, post_scope)
         [call_type, post_scope]
       end
 
+      # v0.0.3 — recognises a small catalogue of RSpec
+      # matcher patterns as assert-shaped narrows on the
+      # local passed to `expect(...)`. The pattern is
+      # matched purely on AST shape; no RBS for RSpec is
+      # required (and none is shipped today).
+      #
+      # Recognised today:
+      #
+      #   expect(x).not_to(be_nil)
+      #   expect(x).to_not(be_nil)
+      #     → narrow `x` AWAY from `NilClass`.
+      #
+      #   expect(x).to(be_a(C))
+      #   expect(x).to(be_kind_of(C))
+      #   expect(x).to(be_an_instance_of(C))
+      #     → narrow `x` to `C` (exact for
+      #       `be_an_instance_of`, subtype-permitting
+      #       otherwise).
+      #
+      # Anything else is silently passed through. Symmetric
+      # negative class assertions (`not_to be_a(C)`) and
+      # narrowing TO `NilClass` are intentionally NOT
+      # modelled: they are rarely useful in practice and
+      # risk masking bugs if the assertion later fails.
+      def apply_rspec_matcher_narrowing(call_node, current_scope)
+        narrow = rspec_matcher_narrowing_request(call_node)
+        return current_scope if narrow.nil?
+
+        local_name = narrow.fetch(:local)
+        current_type = current_scope.local(local_name)
+        return current_scope if current_type.nil?
+
+        narrowed = apply_rspec_narrow(current_type, narrow, current_scope.environment)
+        current_scope.with_local(local_name, narrowed)
+      end
+
+      # Decodes an `expect(x).<chain>` outer call into a
+      # narrowing request hash, or `nil` when the shape is
+      # not recognised. The hash carries `:local` (the local
+      # name being narrowed) plus the narrowing parameters.
+      def rspec_matcher_narrowing_request(call_node)
+        local_name = rspec_expectation_target(call_node)
+        return nil if local_name.nil?
+
+        case call_node.name
+        when :not_to, :to_not
+          rspec_negative_narrow(call_node, local_name)
+        when :to
+          rspec_positive_narrow(call_node, local_name)
+        end
+      end
+
+      def rspec_negative_narrow(call_node, local_name)
+        return nil unless rspec_matcher_argument?(call_node, :be_nil)
+
+        { local: local_name, kind: :not_class, class_name: "NilClass", exact: false }
+      end
+
+      def rspec_positive_narrow(call_node, local_name)
+        matcher = rspec_matcher_node(call_node)
+        return nil if matcher.nil?
+
+        case matcher.name
+        when :be_a, :be_kind_of
+          rspec_be_a_narrow(matcher, local_name, exact: false)
+        when :be_an_instance_of, :be_instance_of
+          rspec_be_a_narrow(matcher, local_name, exact: true)
+        end
+      end
+
+      # `be_a` / `be_kind_of` / `be_an_instance_of` accept a
+      # single class argument — either a `ConstantReadNode`
+      # (`Integer`) or a `ConstantPathNode` (`Rigor::Type::Nominal`).
+      def rspec_be_a_narrow(matcher, local_name, exact:)
+        args = matcher.arguments&.arguments || []
+        return nil unless args.size == 1
+
+        class_name = constant_node_name(args.first)
+        return nil if class_name.nil?
+
+        { local: local_name, kind: :class, class_name: class_name, exact: exact }
+      end
+
+      def apply_rspec_narrow(current_type, narrow, environment)
+        case narrow.fetch(:kind)
+        when :not_class
+          Narrowing.narrow_not_class(current_type, narrow.fetch(:class_name),
+                                     exact: narrow.fetch(:exact), environment: environment)
+        when :class
+          Narrowing.narrow_class(current_type, narrow.fetch(:class_name),
+                                 exact: narrow.fetch(:exact), environment: environment)
+        end
+      end
+
+      # Returns the local name passed to `expect(...)` when
+      # the receiver chain matches `expect(<local>)` exactly,
+      # or nil otherwise. Centralised so each per-matcher
+      # decoder can short-circuit on a non-matching outer
+      # call.
+      def rspec_expectation_target(call_node) # rubocop:disable Metrics/CyclomaticComplexity
+        receiver = call_node.receiver
+        return nil unless receiver.is_a?(Prism::CallNode) && receiver.name == :expect
+        return nil unless receiver.receiver.nil?
+
+        args = receiver.arguments&.arguments || []
+        return nil unless args.size == 1
+
+        target = args.first
+        target.is_a?(Prism::LocalVariableReadNode) ? target.name : nil
+      end
+
+      def rspec_matcher_node(call_node)
+        args = call_node.arguments&.arguments || []
+        return nil unless args.size == 1
+
+        matcher = args.first
+        return nil unless matcher.is_a?(Prism::CallNode) && matcher.receiver.nil? && matcher.block.nil?
+
+        matcher
+      end
+
+      # True when `call_node`'s sole argument is an
+      # implicit-self matcher call with the given name and
+      # no positional arguments — used by the no-arg
+      # matchers (`be_nil`).
+      def rspec_matcher_argument?(call_node, matcher_name)
+        matcher = rspec_matcher_node(call_node)
+        return false if matcher.nil?
+        return false unless matcher.name == matcher_name
+
+        matcher.arguments.nil? || matcher.arguments.arguments.empty?
+      end
+
+      # Decodes a `Prism::ConstantReadNode` /
+      # `Prism::ConstantPathNode` into a colon-joined class
+      # name string, or returns nil for any other node
+      # shape. Mirrors the conservative envelope used by the
+      # `is_a?` / `kind_of?` predicate narrower.
+      def constant_node_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          flatten_constant_path(node)
+        end
+      end
+
+      def flatten_constant_path(node)
+        parts = []
+        cursor = node
+        while cursor.is_a?(Prism::ConstantPathNode)
+          parts.unshift(cursor.name.to_s)
+          cursor = cursor.parent
+        end
+        case cursor
+        when Prism::ConstantReadNode then parts.unshift(cursor.name.to_s)
+        when nil then nil # ::Foo absolute root — preserve as-is
+        else return nil
+        end
+        parts.join("::")
+      end
+
       # v0.0.2 — applies `RBS::Extended` `assert <target> is T`
       # directives to the post-call scope. The conditional
       # variants (`assert-if-true` / `assert-if-false`) are
@@ -685,6 +894,8 @@ module Rigor
       end
 
       def narrow_for_assert_effect(current_type, effect, environment)
+        return effect.refinement_type if effect.refinement?
+
         if effect.negative?
           Narrowing.narrow_not_class(current_type, effect.class_name, exact: false, environment: environment)
         else

data/lib/rigor/rbs_extended.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "type"
+require_relative "builtins/imported_refinements"
 
 module Rigor
   # Slice 7 phase 15 — first-preview reader for the
@@ -40,7 +41,7 @@ module Rigor
   # `::Foo::Bar` style constant path. Negative refinements
   # (`~T`), intersections, and unions are deferred to the
   # next iteration.
-  module RbsExtended
+  module RbsExtended # rubocop:disable Metrics/ModuleLength
     DIRECTIVE_PREFIX = "rigor:v1:"
 
     # Returned for `predicate-if-true` / `predicate-if-false`.
@@ -49,10 +50,19 @@ module Rigor
     # when the directive uses the `~ClassName` form, in
     # which case the engine narrows AWAY from `class_name`
     # (`Narrowing.narrow_not_class`) instead of toward it.
-    PredicateEffect = Data.define(:edge, :target_kind, :target_name, :class_name, :negative) do
+    #
+    # `refinement_type` is non-nil when the right-hand side is
+    # a kebab-case refinement name (`non-empty-string`,
+    # `lowercase-string`, …) instead of a Capitalised class
+    # name. The narrowing tier substitutes the carrier for the
+    # current local type; `class_name` is then nil and
+    # `negative` is false (refinement-form directives do not
+    # support `~T` negation in v0.0.4).
+    PredicateEffect = Data.define(:edge, :target_kind, :target_name, :class_name, :negative, :refinement_type) do
       def truthy_only? = edge == :truthy_only
       def falsey_only? = edge == :falsey_only
       def negative? = negative == true
+      def refinement? = !refinement_type.nil?
     end
 
     # Returned for `assert` / `assert-if-true` /
@@ -70,11 +80,12 @@ module Rigor
     #
     # `negative` mirrors `PredicateEffect`: true when the
     # directive uses `~ClassName` syntax.
-    AssertEffect = Data.define(:condition, :target_kind, :target_name, :class_name, :negative) do
+    AssertEffect = Data.define(:condition, :target_kind, :target_name, :class_name, :negative, :refinement_type) do
       def always? = condition == :always
       def if_truthy_return? = condition == :if_truthy_return
       def if_falsey_return? = condition == :if_falsey_return
       def negative? = negative == true
+      def refinement? = !refinement_type.nil?
     end
 
     module_function
@@ -99,14 +110,26 @@ module Rigor
       effects.uniq
     end
 
+    # The right-hand side accepts either a Capitalised class
+    # name (with optional `~` negation, optional `::` prefix,
+    # qualified names) OR a kebab-case refinement payload
+    # routed through `Builtins::ImportedRefinements::Parser`
+    # (bare names, `name[T]`, `name<min, max>`). The two arms
+    # share the same overall directive shape; the parser
+    # detects which form matched by looking at the `class_name`
+    # vs `refinement` capture groups.
     PREDICATE_DIRECTIVE_PATTERN = /
       \A
       rigor:v1:(?<directive>predicate-if-(?:true|false))
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
-      (?<negation>~?)
-      (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
+      (?:
+        (?<negation>~?)
+        (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
+        |
+        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
+      )
       \s*
       \z
     /x
@@ -118,16 +141,18 @@ module Rigor
 
       directive = match[:directive].to_s
       target = match[:target].to_s
-      class_name = match[:class_name].to_s.sub(/\A::/, "")
       edge = directive == "predicate-if-true" ? :truthy_only : :falsey_only
-      target_kind = target == "self" ? :self : :parameter
-      target_name = target == "self" ? :self : target.to_sym
+      target_kind, target_name = target_fields(target)
+      class_name, refinement_type, negative = resolve_directive_rhs(match)
+      return nil if class_name.nil? && refinement_type.nil?
+
       PredicateEffect.new(
         edge: edge,
         target_kind: target_kind,
         target_name: target_name,
         class_name: class_name,
-        negative: match[:negation].to_s == "~"
+        negative: negative,
+        refinement_type: refinement_type
       )
     end
 
@@ -156,8 +181,12 @@ module Rigor
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
-      (?<negation>~?)
-      (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
+      (?:
+        (?<negation>~?)
+        (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
+        |
+        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
+      )
       \s*
       \z
     /x
@@ -179,16 +208,202 @@ module Rigor
       return nil if condition.nil?
 
       target = match[:target].to_s
-      class_name = match[:class_name].to_s.sub(/\A::/, "")
-      target_kind = target == "self" ? :self : :parameter
-      target_name = target == "self" ? :self : target.to_sym
+      target_kind, target_name = target_fields(target)
+      class_name, refinement_type, negative = resolve_directive_rhs(match)
+      return nil if class_name.nil? && refinement_type.nil?
+
       AssertEffect.new(
         condition: condition,
         target_kind: target_kind,
         target_name: target_name,
         class_name: class_name,
-        negative: match[:negation].to_s == "~"
+        negative: negative,
+        refinement_type: refinement_type
       )
     end
+
+    # Resolves the `class_name` / `refinement` alternation in
+    # the assert / predicate directive patterns. Returns
+    # `[class_name, refinement_type, negative]`:
+    #
+    # - Class-name arm matched: `class_name` is the resolved
+    #   string (leading `::` stripped), `refinement_type` is
+    #   nil, `negative` reflects the optional `~` prefix.
+    # - Refinement arm matched: `class_name` is nil,
+    #   `refinement_type` is the resolved `Rigor::Type`,
+    #   `negative` is `false` (refinement-form directives do
+    #   not support `~` negation in v0.0.4).
+    # - Refinement payload unparseable: returns
+    #   `[nil, nil, false]` so callers can drop the directive
+    #   silently (fail-soft policy).
+    def resolve_directive_rhs(match)
+      class_capture = match[:class_name]
+      return [class_capture.to_s.sub(/\A::/, ""), nil, match[:negation].to_s == "~"] if class_capture
+
+      refinement_capture = match[:refinement]
+      return [nil, nil, false] if refinement_capture.nil?
+
+      type = Builtins::ImportedRefinements.parse(refinement_capture)
+      return [nil, nil, false] if type.nil?
+
+      [nil, type, false]
+    end
+
+    def target_fields(target)
+      if target == "self"
+        %i[self self]
+      else
+        [:parameter, target.to_sym]
+      end
+    end
+
+    # Reads the `rigor:v1:return: <kebab-name>` directive off
+    # `RBS::Definition::Method#annotations`. The directive
+    # overrides a method's RBS-declared return type with one of
+    # the imported-built-in refinements registered in
+    # `Rigor::Builtins::ImportedRefinements`. The override is the
+    # primary integration path for refinement carriers
+    # (`non-empty-string`, `positive-int`, `non-empty-array`, …)
+    # in v0.0 — annotation-driven, opt-in per method, and never
+    # silently rewrites a hand-authored RBS signature outside the
+    # annotation.
+    #
+    # Example annotation in an RBS file:
+    #
+    #   class User
+    #     %a{rigor:v1:return: non-empty-string}
+    #     def name: () -> String
+    #   end
+    #
+    # The RBS-declared return is `String`. The override
+    # tightens it to `non-empty-string` (i.e.
+    # `Difference[String, ""]`) for callers; RBS erasure of the
+    # tightened return goes back to `String` so the round-trip
+    # to ordinary RBS is unaffected.
+    #
+    # Returns the resolved `Rigor::Type` value, or `nil` when:
+    # - the method has no annotations,
+    # - none of the annotations match the `rigor:v1:return:`
+    #   directive,
+    # - the directive's payload names a refinement not
+    #   registered in `Rigor::Builtins::ImportedRefinements`
+    #   (the analyzer prefers a silent miss over crashing on a
+    #   typo; future slices MAY surface the miss as a
+    #   `:warning` self-diagnostic).
+    def read_return_type_override(method_def)
+      return nil if method_def.nil?
+
+      annotations = method_def.annotations
+      return nil if annotations.nil? || annotations.empty?
+
+      annotations.each do |annotation|
+        type = parse_return_type_override(annotation.string)
+        return type if type
+      end
+      nil
+    end
+
+    # The trailing payload supports the full refinement
+    # grammar in `Builtins::ImportedRefinements::Parser` —
+    # bare kebab-case names plus parameterised forms like
+    # `non-empty-array[Integer]`, `non-empty-hash[Symbol,
+    # Integer]`, and `int<5, 10>`. The directive head is
+    # consumed by the regex; the rest is forwarded to the
+    # refinement parser. Anything the parser cannot resolve
+    # falls back to nil so the call site keeps the
+    # RBS-declared return type.
+    RETURN_DIRECTIVE_PATTERN = /
+      \A
+      rigor:v1:return:
+      \s+
+      (?<payload>\S(?:.*\S)?)
+      \s*
+      \z
+    /x
+    private_constant :RETURN_DIRECTIVE_PATTERN
+
+    def parse_return_type_override(string)
+      match = RETURN_DIRECTIVE_PATTERN.match(string)
+      return nil if match.nil?
+
+      Builtins::ImportedRefinements.parse(match[:payload])
+    end
+
+    # Returned for `rigor:v1:param: <name> <refinement>`. The
+    # parameter name is a Ruby identifier (Symbol); the type
+    # is any `Rigor::Type` the refinement parser resolves
+    # (bare kebab-case name, parameterised form, or `int<...>`
+    # range — the same grammar the `return:` directive
+    # accepts).
+    ParamOverride = Data.define(:param_name, :type)
+
+    # Reads every `rigor:v1:param: <name> <refinement>`
+    # directive off `RBS::Definition::Method#annotations` and
+    # returns the resolved `ParamOverride` list. Annotations
+    # the parser cannot resolve (typo, unknown refinement, no
+    # `param:` directive at all) are silently dropped — the
+    # call site keeps the RBS-declared parameter type for
+    # those parameters. The reader accepts a nil method
+    # definition so call sites can pass through optional
+    # method lookups without a guard.
+    #
+    # Example annotation in an RBS file:
+    #
+    #   class Slug
+    #     %a{rigor:v1:param: id is non-empty-string}
+    #     def normalise: (::String id) -> String
+    #   end
+    #
+    # The RBS-declared type of `id` is `String`. The override
+    # tightens it to `non-empty-string` for argument-check
+    # purposes; passing a too-wide `Nominal[String]` argument
+    # is flagged as an argument-type mismatch at the call
+    # site.
+    def read_param_type_overrides(method_def)
+      return [] if method_def.nil?
+
+      annotations = method_def.annotations
+      return [] if annotations.nil? || annotations.empty?
+
+      annotations.filter_map { |annotation| parse_param_annotation(annotation.string) }
+    end
+
+    # Convenience reader for call sites that want to look up
+    # a single override by parameter name. Returns a frozen
+    # Hash<Symbol, Rigor::Type>; missing keys mean "use the
+    # RBS-declared type". Callers MUST treat the hash as
+    # read-only.
+    def param_type_override_map(method_def)
+      read_param_type_overrides(method_def).to_h { |o| [o.param_name, o.type] }.freeze
+    end
+
+    # The `is` glue word is optional so authors can write
+    # either `param: id is non-empty-string` (consistent with
+    # the existing `assert` / `predicate-if-*` directives) or
+    # the terser `param: id non-empty-string`. The trailing
+    # payload accepts the full refinement grammar in
+    # `Builtins::ImportedRefinements::Parser`.
+    PARAM_DIRECTIVE_PATTERN = /
+      \A
+      rigor:v1:param:
+      \s+
+      (?<param>[a-z_][a-zA-Z0-9_]*)
+      \s+
+      (?:is\s+)?
+      (?<payload>\S(?:.*\S)?)
+      \s*
+      \z
+    /x
+    private_constant :PARAM_DIRECTIVE_PATTERN
+
+    def parse_param_annotation(string)
+      match = PARAM_DIRECTIVE_PATTERN.match(string)
+      return nil if match.nil?
+
+      type = Builtins::ImportedRefinements.parse(match[:payload])
+      return nil if type.nil?
+
+      ParamOverride.new(param_name: match[:param].to_sym, type: type)
+    end
   end
 end

data/lib/rigor/scope.rb

@@ -250,6 +250,20 @@ module Rigor
       table[method_name.to_sym]
     end
 
+    # v0.0.3 A — top-level def lookup for implicit-self
+    # calls. Returns the `Prism::DefNode` for a top-level
+    # (or DSL-block-nested, outside any class body) `def
+    # <method_name>` in the file, or nil. The sentinel key
+    # is owned by `Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY`;
+    # consumers should treat its presence as an opaque
+    # implementation detail and go through this accessor.
+    def top_level_def_for(method_name)
+      table = @discovered_def_nodes[Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY]
+      return nil unless table
+
+      table[method_name.to_sym]
+    end
+
     def with_discovered_def_nodes(table)
       rebuild(discovered_def_nodes: table)
     end