rigortype 0.0.4 → 0.0.6

data/lib/rigor/inference/narrowing.rb

@@ -241,6 +241,55 @@ module Rigor
         narrow_class_dispatch(type, class_name, context)
       end
 
+      # Negation pair for `assert_value is ~refinement` /
+      # `predicate-if-* … is ~refinement` directives. Computes
+      # the complement of `refinement` within the current
+      # local's domain `current_type`.
+      #
+      # Carrier-by-carrier rules:
+      #
+      # - `Difference[base, Constant[v]]`. Complement of
+      #   `base \ {v}` within `current_type`. Walk the current
+      #   type's union members, keep each part disjoint from
+      #   `base`, and add the removed-value Constant once when
+      #   any current member covers it. `assert s is
+      #   ~non-empty-string` over `s: String | nil` narrows to
+      #   `Constant[""] | NilClass`.
+      # - `IntegerRange[a, b]` (v0.0.5+ slice). Complement is
+      #   the two open halves `int<min, a-1>` and
+      #   `int<b+1, max>`, each intersected with the
+      #   integer-domain parts of `current_type`. Non-integer
+      #   parts (nil, String, …) of a Union receiver survive
+      #   unchanged. `assert n is ~int<5, 10>` over `n:
+      #   Integer | nil` narrows to `int<min, 4> | int<11,
+      #   max> | NilClass`.
+      # - `Type::Intersection[M1, M2, …]` (v0.0.5+ slice). De
+      #   Morgan: `D \ (M1 ∩ M2) = (D \ M1) ∪ (D \ M2)`. Each
+      #   member's complement is computed independently within
+      #   `current_type` and the results are unioned. Members
+      #   the algebra cannot complement (Refined, non-Constant
+      #   Difference, …) contribute `current_type` itself, so
+      #   the union widens the answer to `current_type` —
+      #   sound but imprecise.
+      # - `Refined[base, predicate]`. Predicate complements are
+      #   not reducible to a finite carrier without a richer
+      #   shape (e.g. `~lowercase-string` is "uppercase OR
+      #   mixed-case"); `current_type` is returned unchanged.
+      def narrow_not_refinement(current_type, refinement_type)
+        case refinement_type
+        when Type::Difference
+          return current_type unless refinement_type.removed.is_a?(Type::Constant)
+
+          complement_difference(current_type, refinement_type)
+        when Type::IntegerRange
+          complement_integer_range(current_type, refinement_type)
+        when Type::Intersection
+          complement_intersection(current_type, refinement_type)
+        else
+          current_type
+        end
+      end
+
       # Public predicate analyser. Returns `[truthy_scope, falsey_scope]`,
       # always; when no narrowing rule matches the predicate node both
       # entries are the receiver scope unchanged.
@@ -321,6 +370,162 @@ module Rigor
       class << self
         private
 
+        # Complement of `Difference[base, Constant[v]]` within
+        # `current_type`. Walks the current type's union members,
+        # keeps each member disjoint from `base` (those values
+        # were never in the refinement to begin with), and adds
+        # the removed-value `Constant[v]` exactly once when any
+        # current member covers it. Members that are fully
+        # contained in the refinement (i.e. inside `base` and
+        # NOT equal to the removed value) are dropped — they are
+        # exactly the values the negation excludes.
+        def complement_difference(current_type, difference)
+          base = difference.base
+          removed = difference.removed
+          parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
+
+          survivors = []
+          add_removed = false
+          parts.each do |part|
+            if base_disjoint?(base, part)
+              survivors << part
+            elsif part_covers_constant?(part, removed)
+              add_removed = true
+            end
+          end
+          survivors << removed if add_removed
+
+          return current_type if survivors.empty?
+
+          Type::Combinator.union(*survivors)
+        end
+
+        def base_disjoint?(base, part)
+          base.accepts(part, mode: :gradual).no?
+        end
+
+        def part_covers_constant?(part, constant)
+          result = part.accepts(constant, mode: :gradual)
+          result.yes? || result.maybe?
+        end
+
+        # Complement of an `IntegerRange[a, b]` within
+        # `current_type`. Splits the range complement into the
+        # two open halves `int<min, a-1>` and `int<b+1, max>`
+        # (skipping a half when its bound is infinity), then
+        # intersects each half with the integer-domain parts of
+        # `current_type`. Non-integer parts of a Union receiver
+        # (nil, String, …) survive unchanged.
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def complement_integer_range(current_type, range)
+          halves = integer_range_complement_halves(range)
+          parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
+
+          survivors = []
+          parts.each do |part|
+            if integer_member?(part)
+              halves.each do |half|
+                meet = intersect_integer_part(part, half)
+                survivors << meet unless meet.nil? || meet.is_a?(Type::Bot)
+              end
+            else
+              survivors << part
+            end
+          end
+
+          return current_type if survivors.empty?
+
+          Type::Combinator.union(*survivors)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # Returns the two open halves of an IntegerRange's
+        # complement: the left half `int<-∞, a-1>` (when `a` is
+        # finite) and the right half `int<b+1, ∞>` (when `b` is
+        # finite). Universal ranges (both bounds infinite) yield
+        # an empty array — the complement is empty.
+        def integer_range_complement_halves(range)
+          halves = []
+          left_max = range.min
+          right_min = range.max
+
+          if left_max.is_a?(Integer)
+            halves << Type::Combinator.integer_range(Type::IntegerRange::NEG_INFINITY, left_max - 1)
+          end
+          if right_min.is_a?(Integer)
+            halves << Type::Combinator.integer_range(right_min + 1, Type::IntegerRange::POS_INFINITY)
+          end
+          halves
+        end
+
+        def integer_member?(part)
+          case part
+          when Type::Constant then part.value.is_a?(Integer)
+          when Type::IntegerRange then true
+          when Type::Nominal then part.class_name == "Integer"
+          else false
+          end
+        end
+
+        # Intersect an integer-domain part with a complement
+        # half-range. For a Nominal[Integer] receiver the meet
+        # is the half itself; for an existing IntegerRange the
+        # meet narrows both bounds; for a Constant[Integer] the
+        # meet is the constant when the half covers it,
+        # otherwise nil.
+        def intersect_integer_part(part, half)
+          case part
+          when Type::Nominal
+            half
+          when Type::IntegerRange
+            integer_range_meet(part, half)
+          when Type::Constant
+            half.covers?(part.value) ? part : nil
+          end
+        end
+
+        def integer_range_meet(left, right)
+          low = numeric_to_bound([integer_bound_value(left.min), integer_bound_value(right.min)].max)
+          high = numeric_to_bound([integer_bound_value(left.max), integer_bound_value(right.max)].min)
+          return nil if integer_range_disjoint?(low, high)
+
+          Type::Combinator.integer_range(low, high)
+        end
+
+        def integer_bound_value(bound)
+          return -Float::INFINITY if bound == Type::IntegerRange::NEG_INFINITY
+          return Float::INFINITY if bound == Type::IntegerRange::POS_INFINITY
+
+          bound
+        end
+
+        def numeric_to_bound(value)
+          return Type::IntegerRange::NEG_INFINITY if value == -Float::INFINITY
+          return Type::IntegerRange::POS_INFINITY if value == Float::INFINITY
+
+          value.to_i
+        end
+
+        def integer_range_disjoint?(low, high)
+          return false if low == Type::IntegerRange::NEG_INFINITY
+          return false if high == Type::IntegerRange::POS_INFINITY
+
+          low > high
+        end
+
+        # De Morgan: `D \ (M1 ∩ M2 ∩ …) = (D \ M1) ∪ (D \ M2) ∪
+        # …`. Each member's complement is computed independently
+        # within `current_type` and the results are unioned.
+        # Members the algebra cannot complement contribute
+        # `current_type` itself, so the union widens to
+        # `current_type` overall — sound but imprecise.
+        def complement_intersection(current_type, intersection)
+          per_member = intersection.members.map do |member|
+            Narrowing.narrow_not_refinement(current_type, member)
+          end
+          Type::Combinator.union(*per_member)
+        end
+
         def falsey_value?(value)
           value.nil? || value == false
         end
@@ -1029,7 +1234,11 @@ module Rigor
         # the effect's `negative?` flag. Shared between
         # predicate-if-* and assert-if-* application paths.
         def narrow_for_effect(current, effect, environment)
-          return effect.refinement_type if effect.respond_to?(:refinement?) && effect.refinement?
+          if effect.respond_to?(:refinement?) && effect.refinement?
+            return narrow_not_refinement(current, effect.refinement_type) if effect.negative?
+
+            return effect.refinement_type
+          end
 
           if effect.negative?
             narrow_not_class(current, effect.class_name, exact: false, environment: environment)

data/lib/rigor/inference/scope_indexer.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../scope"
 require_relative "../type"
+require_relative "narrowing"
 require_relative "statement_evaluator"
 
 module Rigor
@@ -475,16 +476,9 @@ module Rigor
 
         case node
         when Prism::ModuleNode, Prism::ClassNode
-          name = qualified_name_for(node.constant_path)
-          if name
-            full = (qualified_prefix + [name]).join("::")
-            singleton = Type::Combinator.singleton_of(full)
-            identity_table[node.constant_path] = singleton
-            discovered[full] = singleton
-            child_prefix = qualified_prefix + [name]
-            record_declarations(node.body, child_prefix, identity_table, discovered) if node.body
-            return
-          end
+          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)
         end
 
         node.compact_child_nodes.each do |child|
@@ -492,6 +486,60 @@ module Rigor
         end
       end
 
+      def record_class_or_module?(node, qualified_prefix, identity_table, discovered)
+        name = qualified_name_for(node.constant_path)
+        return false unless name
+
+        full = (qualified_prefix + [name]).join("::")
+        singleton = Type::Combinator.singleton_of(full)
+        identity_table[node.constant_path] = singleton
+        discovered[full] = singleton
+        child_prefix = qualified_prefix + [name]
+        record_declarations(node.body, child_prefix, identity_table, discovered) if node.body
+        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.
+      #
+      # 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)
+
+        full = (qualified_prefix + [node.name.to_s]).join("::")
+        discovered[full] = Type::Combinator.singleton_of(full)
+        record_declarations(node.value, qualified_prefix, identity_table, discovered)
+        true
+      end
+
+      # Recognises `Data.define(*Symbol)` and `Data.define(*Symbol) do ... end`
+      # at constant-write rvalue position. The receiver MUST be the bare
+      # `Data` constant (or `::Data`); other receivers (a local variable, a
+      # method call return) are rejected because their identity is not
+      # statically known.
+      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)
+
+        args = node.arguments&.arguments || []
+        args.all?(Prism::SymbolNode)
+      end
+
+      def data_constant_receiver?(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name == :Data
+        when Prism::ConstantPathNode
+          node.parent.nil? && node.name == :Data
+        end
+      end
+
       def qualified_name_for(constant_path_node)
         case constant_path_node
         when Prism::ConstantReadNode
@@ -515,6 +563,13 @@ module Rigor
       # Prism node the StatementEvaluator did not visit (i.e. expression-
       # interior nodes like the receiver/args of a CallNode). Those
       # nodes inherit their nearest recorded ancestor's scope.
+      #
+      # `IfNode` / `UnlessNode` are special-cased: the truthy and falsey
+      # branches each get their predicate's narrowed scope before
+      # recursing. This handles expression-position conditionals
+      # (e.g. `cache[k] = if cond; t; else; e; end` and conditionals
+      # nested as call arguments) which are typed by ExpressionTyper
+      # without going through `eval_if`'s narrowing path.
       def propagate(node, table, parent_scope)
         return unless node.is_a?(Prism::Node)
 
@@ -526,7 +581,28 @@ module Rigor
             parent_scope
           end
 
-        node.compact_child_nodes.each { |child| propagate(child, table, current_scope) }
+        case node
+        when Prism::IfNode
+          propagate_if_branches(node, table, current_scope)
+        when Prism::UnlessNode
+          propagate_unless_branches(node, table, current_scope)
+        else
+          node.compact_child_nodes.each { |child| propagate(child, table, current_scope) }
+        end
+      end
+
+      def propagate_if_branches(node, table, current_scope)
+        truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, current_scope)
+        propagate(node.predicate, table, current_scope) if node.predicate
+        propagate(node.statements, table, truthy_scope) if node.statements
+        propagate(node.subsequent, table, falsey_scope) if node.subsequent
+      end
+
+      def propagate_unless_branches(node, table, current_scope)
+        truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, current_scope)
+        propagate(node.predicate, table, current_scope) if node.predicate
+        propagate(node.statements, table, falsey_scope) if node.statements
+        propagate(node.else_clause, table, truthy_scope) if node.else_clause
       end
     end
     # rubocop:enable Metrics/ModuleLength

data/lib/rigor/inference/statement_evaluator.rb

@@ -894,7 +894,11 @@ module Rigor
       end
 
       def narrow_for_assert_effect(current_type, effect, environment)
-        return effect.refinement_type if effect.refinement?
+        if effect.refinement?
+          return Narrowing.narrow_not_refinement(current_type, effect.refinement_type) if effect.negative?
+
+          return effect.refinement_type
+        end
 
         if effect.negative?
           Narrowing.narrow_not_class(current_type, effect.class_name, exact: false, environment: environment)

data/lib/rigor/rbs_extended.rb

@@ -124,8 +124,8 @@ module Rigor
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
+      (?<negation>~?)
       (?:
-        (?<negation>~?)
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
         (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
@@ -181,8 +181,8 @@ module Rigor
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
+      (?<negation>~?)
       (?:
-        (?<negation>~?)
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
         (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
@@ -231,14 +231,19 @@ module Rigor
     #   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).
+    #   `negative` reflects the `~` prefix. v0.0.5 supports
+    #   refinement-form negation for the `Difference[base,
+    #   Constant]` shape (the narrowing tier computes the
+    #   complement decomposition); other refinement carriers
+    #   under negation fall back to the conservative
+    #   "current_type unchanged" answer.
     # - Refinement payload unparseable: returns
     #   `[nil, nil, false]` so callers can drop the directive
     #   silently (fail-soft policy).
     def resolve_directive_rhs(match)
+      negative = match[:negation].to_s == "~"
       class_capture = match[:class_name]
-      return [class_capture.to_s.sub(/\A::/, ""), nil, match[:negation].to_s == "~"] if class_capture
+      return [class_capture.to_s.sub(/\A::/, ""), nil, negative] if class_capture
 
       refinement_capture = match[:refinement]
       return [nil, nil, false] if refinement_capture.nil?
@@ -246,7 +251,7 @@ module Rigor
       type = Builtins::ImportedRefinements.parse(refinement_capture)
       return [nil, nil, false] if type.nil?
 
-      [nil, type, false]
+      [nil, type, negative]
     end
 
     def target_fields(target)

data/lib/rigor/type/integer_range.rb

@@ -65,11 +65,13 @@ module Rigor
       # `:neg_infinity`). Use this in arithmetic comparisons; never compare
       # `:neg_infinity` directly with an `Integer`.
       def lower
-        min == NEG_INFINITY ? -Float::INFINITY : min
+        m = min
+        m.is_a?(Symbol) ? -Float::INFINITY : m
       end
 
       def upper
-        max == POS_INFINITY ? Float::INFINITY : max
+        m = max
+        m.is_a?(Symbol) ? Float::INFINITY : m
       end
 
       ALIAS_NAMES = {

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.0.4"
+  VERSION = "0.0.6"
 end

data/sig/rigor/environment.rbs

@@ -38,15 +38,13 @@ module Rigor
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath]) -> void
       def class_known?: (String | Symbol name) -> bool
-      def instance_definition: (String | Symbol class_name) -> untyped
-      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
-      def singleton_definition: (String | Symbol class_name) -> untyped
-      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
+      def instance_definition: (String | Symbol class_name) -> untyped?
+      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def singleton_definition: (String | Symbol class_name) -> untyped?
+      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?
-      def instance_definition: (String | Symbol class_name) -> untyped?
-      def singleton_definition: (String | Symbol class_name) -> untyped?
     end
 
     class RbsHierarchy

data/sig/rigor/inference.rbs

@@ -85,6 +85,7 @@ module Rigor
       def self?.narrow_not_equal: (Type::t type, untyped literal) -> Type::t
       def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped
@@ -131,7 +132,7 @@ module Rigor
     module ScopeIndexer
       def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
       def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
-      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] table) -> void
+      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void

data/sig/rigor/type.rbs

@@ -8,9 +8,9 @@ module Rigor
       def self.instance: () -> Top
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -21,9 +21,9 @@ module Rigor
       def self.instance: () -> Bot
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -35,9 +35,9 @@ module Rigor
       def initialize: (Type::t static_facet) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -49,9 +49,9 @@ module Rigor
       def initialize: (untyped value) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -68,14 +68,14 @@ module Rigor
       def finite?: () -> bool
       def cardinality: () -> (Integer | Float)
       def covers?: (untyped value) -> bool
-      def lower: () -> Numeric
-      def upper: () -> Numeric
+      def lower: () -> (Integer | Float)
+      def upper: () -> (Integer | Float)
       def describe: (?Symbol verbosity) -> String
       def generic_description: () -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -88,9 +88,9 @@ module Rigor
       def initialize: (String class_name, ?Array[Type::t] type_args) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -102,9 +102,9 @@ module Rigor
       def initialize: (String class_name) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -116,9 +116,9 @@ module Rigor
       def initialize: (Array[Type::t] members) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -131,9 +131,9 @@ module Rigor
       def initialize: (Type::t base, Type::t removed) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -146,9 +146,9 @@ module Rigor
       def initialize: (Type::t base, Symbol predicate_id) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def matches?: (untyped value) -> bool?
       def ==: (untyped other) -> bool
@@ -161,9 +161,9 @@ module Rigor
       def initialize: (Array[Type::t] members) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -175,9 +175,9 @@ module Rigor
       def initialize: (Array[Type::t] elements) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -198,9 +198,9 @@ module Rigor
       def required_key?: (untyped key) -> bool
       def optional_key?: (untyped key) -> bool
       def read_only_key?: (untyped key) -> bool
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer