rigortype 0.0.1 → 0.0.2

data/lib/rigor/configuration.rb

@@ -9,12 +9,16 @@ module Rigor
       "target_ruby" => "4.0",
       "paths" => ["lib"],
       "plugins" => [],
+      "disable" => [],
+      "libraries" => [],
+      "signature_paths" => nil,
       "cache" => {
         "path" => ".rigor/cache"
       }
     }.freeze
 
-    attr_reader :target_ruby, :paths, :plugins, :cache_path
+    attr_reader :target_ruby, :paths, :plugins, :cache_path, :disabled_rules,
+                :libraries, :signature_paths
 
     def self.load(path = DEFAULT_PATH)
       data = if File.exist?(path)
@@ -26,12 +30,16 @@ module Rigor
       new(DEFAULTS.merge(data))
     end
 
-    def initialize(data = DEFAULTS)
+    def initialize(data = DEFAULTS) # rubocop:disable Metrics/AbcSize
       cache = DEFAULTS.fetch("cache").merge(data.fetch("cache", {}))
 
       @target_ruby = data.fetch("target_ruby", DEFAULTS.fetch("target_ruby")).to_s
       @paths = Array(data.fetch("paths", DEFAULTS.fetch("paths"))).map(&:to_s)
       @plugins = Array(data.fetch("plugins", DEFAULTS.fetch("plugins"))).map(&:to_s)
+      @disabled_rules = Array(data.fetch("disable", DEFAULTS.fetch("disable"))).map(&:to_s).freeze
+      @libraries = Array(data.fetch("libraries", DEFAULTS.fetch("libraries"))).map(&:to_s).freeze
+      sig_paths = data.fetch("signature_paths", DEFAULTS.fetch("signature_paths"))
+      @signature_paths = sig_paths.nil? ? nil : Array(sig_paths).map(&:to_s).freeze
       @cache_path = cache.fetch("path").to_s
     end
 
@@ -40,6 +48,9 @@ module Rigor
         "target_ruby" => target_ruby,
         "paths" => paths,
         "plugins" => plugins,
+        "disable" => disabled_rules,
+        "libraries" => libraries,
+        "signature_paths" => signature_paths,
         "cache" => {
           "path" => cache_path
         }

data/lib/rigor/environment.rb

@@ -35,7 +35,9 @@ module Rigor
     # a strictly RBS-core view MUST construct an `RbsLoader`
     # directly instead of going through `for_project`.
     DEFAULT_LIBRARIES = %w[
-      pathname optparse json yaml fileutils tempfile uri logger date
+      pathname optparse json yaml fileutils tempfile tmpdir
+      stringio forwardable digest securerandom
+      uri logger date
       prism rbs
     ].freeze
 

data/lib/rigor/inference/acceptance.rb

@@ -188,6 +188,8 @@ module Rigor
             accepts_nominal_from_nominal(self_type, other_type, mode)
           when Type::Constant
             accepts_nominal_from_constant(self_type, other_type, mode)
+          when Type::Singleton
+            accepts_nominal_from_singleton(self_type, other_type, mode)
           when Type::Tuple
             accepts(self_type, project_tuple_to_nominal(other_type), mode: mode)
               .with_reason("projected Tuple to Nominal[Array]")
@@ -202,6 +204,35 @@ module Rigor
           end
         end
 
+        # v0.0.2 — meta-type rule. A `Singleton[T]` is the
+        # class object for `T`, so it is an instance of
+        # `Class` (when `T` is a class) and always an instance
+        # of `Module`. Without this rule a method whose
+        # parameter is typed `Class | Module` would reject
+        # every `is_a?(SomeClass)` call and similar
+        # introspection patterns. The rule conservatively
+        # answers `:yes` for `Module` (every singleton is at
+        # least a Module) and for `Class` / `Object` /
+        # `BasicObject` (the class object inherits from
+        # those). Other Nominals fall through to the default
+        # `:no`.
+        META_NOMINALS_FROM_SINGLETON = %w[Module Class Object BasicObject].freeze
+        private_constant :META_NOMINALS_FROM_SINGLETON
+
+        def accepts_nominal_from_singleton(self_type, other_type, mode)
+          if META_NOMINALS_FROM_SINGLETON.include?(self_type.class_name)
+            return Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "Singleton[#{other_type.class_name}] is-a #{self_type.class_name}"
+            )
+          end
+
+          Type::AcceptsResult.no(
+            mode: mode,
+            reasons: "Nominal[#{self_type.class_name}] rejects Singleton[#{other_type.class_name}]"
+          )
+        end
+
         def accepts_nominal_from_nominal(self_type, other_type, mode)
           class_result = class_subtype_result(
             target_name: self_type.class_name,

data/lib/rigor/inference/expression_typer.rb

@@ -753,6 +753,14 @@ module Rigor
         )
         return result if result
 
+        # v0.0.2 #5 — inter-procedural inference for
+        # user-defined methods. When dispatch misses but the
+        # receiver is a user class with a `def` body, re-type
+        # the body with the call's argument types bound and
+        # return the body's last-expression type.
+        user_inference = try_user_method_inference(receiver, node, arg_types)
+        return user_inference if user_inference
+
         # Dynamic-origin propagation: when the receiver is Dynamic[T] and
         # no positive rule resolves the call, the result inherits the
         # dynamic origin. Per the value-lattice algebra, this is a
@@ -763,6 +771,102 @@ module Rigor
         fallback_for(node, family: :prism)
       end
 
+      # v0.0.2 #5 — re-types the body of a user-defined
+      # instance method with the call site's argument types
+      # bound to the method's parameters. Used as a
+      # last-resort tier after `MethodDispatcher.dispatch`
+      # has exhausted its catalogue (RBS, shape, constant
+      # folding, user-class fallback). Returns nil when:
+      #
+      # - the receiver is not `Nominal[T]` for some T;
+      # - no def_node is recorded for that class/method
+      #   (the receiver is foreign or has only an RBS sig);
+      # - the def has no body, or has a parameter shape we
+      #   cannot bind from the call's positional args;
+      # - the inference is already in progress for this
+      #   (class, method, signature) tuple — recursion
+      #   safety net.
+      def try_user_method_inference(receiver, call_node, arg_types)
+        return nil unless receiver.is_a?(Type::Nominal)
+
+        def_node = scope.user_def_for(receiver.class_name, call_node.name)
+        return nil if def_node.nil?
+
+        infer_user_method_return(def_node, receiver, arg_types)
+      rescue StandardError
+        nil
+      end
+
+      INFERENCE_GUARD_KEY = :__rigor_user_method_inference_stack__
+      private_constant :INFERENCE_GUARD_KEY
+
+      def infer_user_method_return(def_node, receiver, arg_types)
+        return nil if def_node.body.nil?
+
+        body_scope = build_user_method_body_scope(def_node, receiver, arg_types)
+        return nil if body_scope.nil?
+
+        signature = [receiver.class_name, def_node.name, arg_types.map { |t| t.describe(:short) }]
+        stack = (Thread.current[INFERENCE_GUARD_KEY] ||= [])
+        return Type::Combinator.untyped if stack.include?(signature)
+
+        stack.push(signature)
+        begin
+          type, _post = body_scope.evaluate(def_node.body)
+          type
+        ensure
+          stack.pop
+        end
+      end
+
+      # Builds the body scope for a user-defined instance
+      # method call: a fresh `Scope` with `self_type` set to
+      # the receiver's nominal type, the project-wide
+      # accumulators inherited (so the body sees the same
+      # `discovered_classes` / `class_ivars` / etc. the
+      # caller does), and required positional parameters
+      # bound from the call's `arg_types` by index. Returns
+      # nil when the parameter shape is too complex for the
+      # first-iteration binder (rest args, keyword args,
+      # block params, etc.).
+      def build_user_method_body_scope(def_node, receiver, arg_types) # rubocop:disable Metrics/AbcSize
+        params = def_node.parameters
+        required = params&.requireds || []
+        return nil unless params.nil? || user_method_param_shape_simple?(params)
+        return nil unless required.size == arg_types.size
+
+        fresh = Scope.empty(environment: scope.environment)
+                     .with_declared_types(scope.declared_types)
+                     .with_discovered_classes(scope.discovered_classes)
+                     .with_in_source_constants(scope.in_source_constants)
+                     .with_class_ivars(scope.class_ivars)
+                     .with_class_cvars(scope.class_cvars)
+                     .with_program_globals(scope.program_globals)
+                     .with_discovered_methods(scope.discovered_methods)
+                     .with_discovered_def_nodes(scope.discovered_def_nodes)
+                     .with_self_type(receiver)
+
+        required.each_with_index do |param, index|
+          fresh = fresh.with_local(param.name, arg_types[index])
+        end
+        fresh
+      end
+
+      # First iteration accepts only required positional
+      # parameters: `def foo(a, b, c)`. Optionals, rest,
+      # keyword params, and block params disqualify the
+      # method from inference (the caller observes
+      # `Dynamic[Top]` instead).
+      def user_method_param_shape_simple?(params)
+        return false unless params.is_a?(Prism::ParametersNode)
+
+        params.optionals.empty? &&
+          params.rest.nil? &&
+          params.keywords.empty? &&
+          params.keyword_rest.nil? &&
+          params.block.nil?
+      end
+
       # Slice A-engine. Implicit-self calls (no `node.receiver`)
       # adopt the surrounding scope's `self_type` as their receiver
       # so calls like `attr_reader_method_name` or

data/lib/rigor/inference/narrowing.rb

@@ -424,7 +424,32 @@ module Rigor
           # `rigor:v1:predicate-if-true` / `predicate-if-false`
           # annotations, apply them to narrow the corresponding
           # local-variable arguments on each edge.
-          analyse_rbs_extended_predicate(node, scope)
+          predicate_result = analyse_rbs_extended_predicate(node, scope)
+          assert_result = analyse_rbs_extended_assert_if(node, scope)
+          merge_extended_results(predicate_result, assert_result, scope)
+        end
+
+        # Combines two `[truthy_scope, falsey_scope]` pair
+        # results from sibling RBS::Extended analysers
+        # (`predicate-if-*` and `assert-if-*`). When only one
+        # side fires, return it directly; when both fire the
+        # right side's per-local deltas are applied on top of
+        # the left side's edges so the rules compose.
+        def merge_extended_results(left, right, base_scope)
+          return left if right.nil?
+          return right if left.nil?
+
+          [
+            merge_scope_pair(left[0], right[0], base_scope),
+            merge_scope_pair(left[1], right[1], base_scope)
+          ]
+        end
+
+        def merge_scope_pair(left_scope, right_scope, base_scope)
+          right_scope.locals.reduce(left_scope) do |acc, (name, type)|
+            base_type = base_scope.local(name)
+            type.equal?(base_type) ? acc : acc.with_local(name, type)
+          end
         end
 
         def dispatch_call(node, scope, name)
@@ -669,6 +694,73 @@ module Rigor
           [truthy_scope, falsey_scope]
         end
 
+        # v0.0.2 — `assert-if-true` / `assert-if-false`. Reads
+        # the conditional assertion effects off the called
+        # method and narrows the matching argument on the
+        # corresponding edge. The unconditional `assert`
+        # variant is NOT applied here; `StatementEvaluator`
+        # applies it directly to the post-call scope.
+        def analyse_rbs_extended_assert_if(node, scope)
+          method_def = resolve_rbs_extended_method(node, scope)
+          return nil if method_def.nil?
+
+          effects = RbsExtended.read_assert_effects(method_def).reject(&:always?)
+          return nil if effects.empty?
+
+          truthy_scope = scope
+          falsey_scope = scope
+          effects.each do |effect|
+            truthy_scope, falsey_scope =
+              apply_assert_if_effect(effect, node, scope, truthy_scope, falsey_scope, method_def)
+          end
+          [truthy_scope, falsey_scope]
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def apply_assert_if_effect(effect, call_node, entry_scope, truthy_scope, falsey_scope, method_def)
+          target_node = effect_target_node(effect, call_node, method_def)
+          return [truthy_scope, falsey_scope] unless target_node.is_a?(Prism::LocalVariableReadNode)
+
+          local_name = target_node.name
+          current = entry_scope.local(local_name)
+          return [truthy_scope, falsey_scope] if current.nil?
+
+          narrowed = narrow_for_effect(current, effect, entry_scope.environment)
+          if effect.if_truthy_return?
+            [truthy_scope.with_local(local_name, narrowed), falsey_scope]
+          else
+            [truthy_scope, falsey_scope.with_local(local_name, narrowed)]
+          end
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        # v0.0.2 #3 — resolves an effect's target node. For
+        # `target: <param>` we look up the matching positional
+        # argument; for `target: self` we use the call's
+        # receiver. In both cases the caller still requires a
+        # `Prism::LocalVariableReadNode` for narrowing to
+        # actually fire (the engine's narrowing surface only
+        # rebinds locals).
+        def effect_target_node(effect, call_node, method_def)
+          if effect.target_kind == :self
+            call_node.receiver
+          else
+            lookup_positional_arg(call_node, method_def, effect.target_name)
+          end
+        end
+
+        # v0.0.2 — selects `narrow_class` (positive) or
+        # `narrow_not_class` (negative `~T` form) based on
+        # the effect's `negative?` flag. Shared between
+        # predicate-if-* and assert-if-* application paths.
+        def narrow_for_effect(current, effect, environment)
+          if effect.negative?
+            narrow_not_class(current, effect.class_name, exact: false, environment: environment)
+          else
+            narrow_class(current, effect.class_name, exact: false, environment: environment)
+          end
+        end
+
         def resolve_rbs_extended_method(node, scope)
           loader = scope.environment.rbs_loader
           return nil if loader.nil?
@@ -709,15 +801,14 @@ module Rigor
 
         # rubocop:disable Metrics/ParameterLists
         def apply_predicate_effect(effect, call_node, entry_scope, truthy_scope, falsey_scope, method_def)
-          arg_node = lookup_positional_arg(call_node, method_def, effect.target_name)
-          return [truthy_scope, falsey_scope] if effect.target_kind != :parameter
-          return [truthy_scope, falsey_scope] unless arg_node.is_a?(Prism::LocalVariableReadNode)
+          target_node = effect_target_node(effect, call_node, method_def)
+          return [truthy_scope, falsey_scope] unless target_node.is_a?(Prism::LocalVariableReadNode)
 
-          local_name = arg_node.name
+          local_name = target_node.name
           current = entry_scope.local(local_name)
           return [truthy_scope, falsey_scope] if current.nil?
 
-          narrowed = narrow_class(current, effect.class_name, exact: false, environment: entry_scope.environment)
+          narrowed = narrow_for_effect(current, effect, entry_scope.environment)
           if effect.truthy_only?
             [truthy_scope.with_local(local_name, narrowed), falsey_scope]
           else

data/lib/rigor/inference/scope_indexer.rb

@@ -98,6 +98,13 @@ module Rigor
         discovered_methods = build_discovered_methods(root)
         seeded_scope = seeded_scope.with_discovered_methods(discovered_methods)
 
+        # v0.0.2 #5 — also record the def node itself for
+        # instance methods so the engine can re-type the body
+        # when a call site dispatches against a user-defined
+        # method without an RBS sig.
+        discovered_def_nodes = build_discovered_def_nodes(root)
+        seeded_scope = seeded_scope.with_discovered_def_nodes(discovered_def_nodes)
+
         table = {}.compare_by_identity
         table.default = seeded_scope
 
@@ -369,6 +376,57 @@ module Rigor
         accumulator[class_name][def_node.name] = kind
       end
 
+      # v0.0.2 #5 — instance-side def-node recording. Walks
+      # class bodies the same way as `build_discovered_methods`
+      # but records the actual `Prism::DefNode` for each
+      # **instance** method so `ExpressionTyper` can re-type
+      # the body at the call site for inter-procedural return
+      # inference. Singleton methods and `define_method` calls
+      # are intentionally skipped: the inference path needs a
+      # statically introspectable body, and singleton dispatch
+      # has its own complications (Class / Module ancestry)
+      # the first-iteration rule does not yet model.
+      def build_discovered_def_nodes(root)
+        accumulator = {}
+        walk_def_nodes(root, [], false, accumulator)
+        accumulator.transform_values(&:freeze).freeze
+      end
+
+      def walk_def_nodes(node, qualified_prefix, in_singleton_class, accumulator) # rubocop:disable Metrics/CyclomaticComplexity
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          name = qualified_name_for(node.constant_path)
+          if name
+            child_prefix = qualified_prefix + [name]
+            walk_def_nodes(node.body, child_prefix, false, accumulator) if node.body
+            return
+          end
+        when Prism::SingletonClassNode
+          if node.expression.is_a?(Prism::SelfNode) && node.body
+            walk_def_nodes(node.body, qualified_prefix, true, accumulator)
+            return
+          end
+        when Prism::DefNode
+          record_def_node(node, qualified_prefix, in_singleton_class, accumulator)
+          return
+        end
+
+        node.compact_child_nodes.each do |child|
+          walk_def_nodes(child, qualified_prefix, in_singleton_class, accumulator)
+        end
+      end
+
+      def record_def_node(def_node, qualified_prefix, in_singleton_class, accumulator)
+        return if qualified_prefix.empty?
+        return if def_node.receiver.is_a?(Prism::SelfNode) || in_singleton_class
+
+        class_name = qualified_prefix.join("::")
+        accumulator[class_name] ||= {}
+        accumulator[class_name][def_node.name] = def_node
+      end
+
       def record_define_method(call_node, qualified_prefix, in_singleton_class, accumulator)
         return if qualified_prefix.empty?
         return if call_node.arguments.nil? || call_node.arguments.arguments.empty?

data/lib/rigor/inference/statement_evaluator.rb

@@ -605,9 +605,103 @@ module Rigor
         call_type = scope.type_of(node, tracer: tracer)
         evaluate_block_if_present(node)
         post_scope = record_closure_escape_if_any(node)
+        post_scope = apply_rbs_extended_assertions(node, post_scope)
         [call_type, post_scope]
       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
+      # NOT applied here — they refine the scope only when the
+      # call is observed as a truthy / falsey predicate, which
+      # `Narrowing.predicate_scopes` handles separately.
+      def apply_rbs_extended_assertions(call_node, current_scope)
+        method_def = resolve_call_method(call_node, current_scope)
+        return current_scope if method_def.nil?
+
+        effects = RbsExtended.read_assert_effects(method_def)
+        return current_scope if effects.empty?
+
+        effects.reduce(current_scope) do |scope_acc, effect|
+          next scope_acc unless effect.always?
+
+          apply_assert_effect(effect, call_node, scope_acc, method_def)
+        end
+      end
+
+      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        receiver_node = call_node.receiver
+        receiver_type =
+          if receiver_node
+            current_scope.type_of(receiver_node, tracer: tracer)
+          else
+            current_scope.self_type
+          end
+        return nil if receiver_type.nil?
+
+        loader = current_scope.environment.rbs_loader
+        return nil if loader.nil?
+
+        class_name = assertion_class_name(receiver_type)
+        return nil if class_name.nil?
+        return nil unless loader.class_known?(class_name)
+
+        if receiver_type.is_a?(Type::Singleton)
+          loader.singleton_method(class_name: class_name, method_name: call_node.name)
+        else
+          loader.instance_method(class_name: class_name, method_name: call_node.name)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def assertion_class_name(receiver_type)
+        case receiver_type
+        when Type::Nominal, Type::Singleton then receiver_type.class_name
+        end
+      end
+
+      def apply_assert_effect(effect, call_node, current_scope, method_def)
+        target_node = assert_effect_target_node(effect, call_node, method_def)
+        return current_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
+
+        local_name = target_node.name
+        current_type = current_scope.local(local_name)
+        return current_scope if current_type.nil?
+
+        narrowed = narrow_for_assert_effect(current_type, effect, current_scope.environment)
+        current_scope.with_local(local_name, narrowed)
+      end
+
+      # v0.0.2 #3 — same `target: self` accommodation as
+      # `Narrowing.effect_target_node`: the call's receiver
+      # serves as the target for self-targeted directives.
+      def assert_effect_target_node(effect, call_node, method_def)
+        if effect.target_kind == :self
+          call_node.receiver
+        else
+          lookup_assert_arg(call_node, method_def, effect.target_name)
+        end
+      end
+
+      def narrow_for_assert_effect(current_type, effect, environment)
+        if effect.negative?
+          Narrowing.narrow_not_class(current_type, effect.class_name, exact: false, environment: environment)
+        else
+          Narrowing.narrow_class(current_type, effect.class_name, exact: false, environment: environment)
+        end
+      end
+
+      def lookup_assert_arg(call_node, method_def, target_name)
+        arguments = call_node.arguments&.arguments || []
+        method_def.method_types.each do |mt|
+          params = mt.type.required_positionals + mt.type.optional_positionals
+          index = params.find_index { |param| param.name == target_name }
+          return arguments[index] if index && arguments[index]
+        end
+        nil
+      end
+
       def evaluate_block_if_present(node)
         block = node.block
         return unless block.is_a?(Prism::BlockNode)

data/lib/rigor/rbs_extended.rb

@@ -10,20 +10,28 @@ module Rigor
   # This module reads `%a{rigor:v1:<directive> <payload>}`
   # annotations off RBS method definitions and returns
   # well-typed effect objects the inference engine can
-  # consume. The first preview ships only the **type
-  # predicate** directives:
+  # consume. v0.0.2 recognises:
   #
   # - `rigor:v1:predicate-if-true <target> is <ClassName>`
   # - `rigor:v1:predicate-if-false <target> is <ClassName>`
+  # - `rigor:v1:assert <target> is <ClassName>`
+  # - `rigor:v1:assert-if-true <target> is <ClassName>`
+  # - `rigor:v1:assert-if-false <target> is <ClassName>`
   #
-  # Other directives in the spec (`assert`, `assert-if-true`,
-  # `assert-if-false`, `param`, `return`, `conforms-to`, ...)
-  # are intentionally deferred. Annotations whose key is in
-  # the `rigor:v1:` namespace but whose directive is
-  # unrecognised are silently ignored at first-preview
-  # quality (a future slice MAY surface them as
-  # diagnostics-on-Rigor-itself per the spec's "unsupported
-  # metadata" guidance).
+  # `predicate-if-*` fires when the call is used as an
+  # `if` / `unless` condition; `assert` fires unconditionally
+  # at the call's post-scope; `assert-if-true` /
+  # `assert-if-false` fire at the post-scope only when the
+  # call's return value can be observed as truthy / falsey
+  # (currently: when the call is the predicate of a
+  # subsequent `if` / `unless`). Other directives in the spec
+  # (`param`, `return`, `conforms-to`, negation `~T`,
+  # `target: self` narrowing, ...) remain on the v0.0.x
+  # roadmap. Annotations whose key is in the `rigor:v1:`
+  # namespace but whose directive is unrecognised are
+  # silently ignored at first-preview quality (a future slice
+  # MAY surface them as diagnostics-on-Rigor-itself per the
+  # spec's "unsupported metadata" guidance).
   #
   # The parser is minimal: it accepts a strict shape
   # `<target> is <ClassName>` where `<target>` is a Ruby
@@ -37,10 +45,36 @@ module Rigor
 
     # Returned for `predicate-if-true` / `predicate-if-false`.
     # `target_kind` is `:parameter` (with `target_name` the
-    # Ruby parameter symbol) or `:self`.
-    PredicateEffect = Data.define(:edge, :target_kind, :target_name, :class_name) do
+    # Ruby parameter symbol) or `:self`. `negative` is true
+    # 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
       def truthy_only? = edge == :truthy_only
       def falsey_only? = edge == :falsey_only
+      def negative? = negative == true
+    end
+
+    # Returned for `assert` / `assert-if-true` /
+    # `assert-if-false`. `condition` is one of:
+    #
+    # - `:always`           — refines `target` at the call's
+    #                        post-scope unconditionally
+    #                        (`assert`).
+    # - `:if_truthy_return` — refines `target` only when the
+    #                        call's return value is observed
+    #                        as truthy (currently: as the
+    #                        predicate of a subsequent
+    #                        `if` / `unless`).
+    # - `:if_falsey_return` — symmetric for falsey.
+    #
+    # `negative` mirrors `PredicateEffect`: true when the
+    # directive uses `~ClassName` syntax.
+    AssertEffect = Data.define(:condition, :target_kind, :target_name, :class_name, :negative) 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
     end
 
     module_function
@@ -71,6 +105,7 @@ 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_]*)*)
       \s*
       \z
@@ -91,7 +126,68 @@ module Rigor
         edge: edge,
         target_kind: target_kind,
         target_name: target_name,
-        class_name: class_name
+        class_name: class_name,
+        negative: match[:negation].to_s == "~"
+      )
+    end
+
+    # Reads RBS::Extended assertion effects (`assert`,
+    # `assert-if-true`, `assert-if-false`) off
+    # `RBS::Definition::Method#annotations`. Returns an empty
+    # array when no recognised assertion directives are
+    # attached to the method.
+    def read_assert_effects(method_def)
+      return [] if method_def.nil?
+
+      annotations = method_def.annotations
+      return [] if annotations.nil? || annotations.empty?
+
+      effects = []
+      annotations.each do |annotation|
+        effect = parse_assert_annotation(annotation.string)
+        effects << effect if effect
+      end
+      effects.uniq
+    end
+
+    ASSERT_DIRECTIVE_PATTERN = /
+      \A
+      rigor:v1:(?<directive>assert(?:-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_]*)*)
+      \s*
+      \z
+    /x
+    private_constant :ASSERT_DIRECTIVE_PATTERN
+
+    ASSERT_CONDITIONS = {
+      "assert" => :always,
+      "assert-if-true" => :if_truthy_return,
+      "assert-if-false" => :if_falsey_return
+    }.freeze
+    private_constant :ASSERT_CONDITIONS
+
+    def parse_assert_annotation(string)
+      match = ASSERT_DIRECTIVE_PATTERN.match(string)
+      return nil if match.nil?
+
+      directive = match[:directive].to_s
+      condition = ASSERT_CONDITIONS[directive]
+      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
+      AssertEffect.new(
+        condition: condition,
+        target_kind: target_kind,
+        target_name: target_name,
+        class_name: class_name,
+        negative: match[:negation].to_s == "~"
       )
     end
   end