diff --git a/core/integer.rbs b/core/integer.rbs
index f20d26d39..a8d16e83b 100644
--- a/core/integer.rbs
+++ b/core/integer.rbs
@@ -128,7 +128,7 @@ class Integer < Numeric
   #
   # Raises an exception if `numeric` is negative.
   #
-  def self.sqrt: (int n) -> Integer
+  def self.sqrt: (int object) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -146,11 +146,9 @@ class Integer < Numeric
   #
   # Raises an exception unless `object.to_int` returns an Integer object.
   #
-  def self.try_convert: (int) -> Integer
+  def self.try_convert: (int object) -> Integer
                       | (untyped) -> Integer?
 
-  public
-
   # <!--
   #   rdoc-file=numeric.c
   #   - self % other -> real_number
@@ -178,10 +176,9 @@ class Integer < Numeric
   #     10 % 3.0            # => 1.0
   #     10 % Rational(3, 1) # => (1/1)
   #
-  def %: (Float) -> Float
-       | (Rational) -> Rational
-       | (Integer) -> Integer
-       | (Numeric) -> Numeric
+  def %: (Integer other) -> Integer
+       | (Float other) -> Float
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpMod[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -196,7 +193,8 @@ class Integer < Numeric
   #
   # Related: Integer#| (bitwise OR), Integer#^ (bitwise EXCLUSIVE OR).
   #
-  def &: (Integer) -> Integer
+  def &: (Integer other) -> Integer
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpAnd[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -211,10 +209,10 @@ class Integer < Numeric
   #     4 * Rational(1, 3) # => (4/3)
   #     4 * Complex(2, 0)  # => (8+0i)
   #
-  def *: (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-       | (Integer) -> Integer
+  def *: (Integer other) -> Integer
+       | (Float other) -> Float
+       | (Complex other) -> Complex
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpMul[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -230,10 +228,9 @@ class Integer < Numeric
   #     2 ** Rational(3, 1) # => (8/1)
   #     2 ** Complex(3, 0)  # => (8+0i)
   #
-  def **: (Integer) -> Numeric
-        | (Float) -> Numeric
-        | (Rational) -> Numeric
-        | (Complex) -> Complex
+  def **: (Integer other) -> (Integer | Rational)
+        | (Float other) -> (Float | Complex)
+        | [X, R] (Numeric::_Coerce[self, Numeric::_OpPow[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -248,12 +245,10 @@ class Integer < Numeric
   #     2 + Rational(2, 1) # => (4/1)
   #     2 + Complex(2, 0)  # => (4+0i)
   #
-  def +: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
-
-  def +@: () -> Integer
+  def +: (Integer other) -> Integer
+       | (Float other) -> Float
+       | (Complex other) -> Complex
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpAdd[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -268,10 +263,9 @@ class Integer < Numeric
   #     4 - Rational(2, 1) # => (2/1)
   #     4 - Complex(2, 0)  # => (2+0i)
   #
-  def -: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
+  def -: (Integer other) -> Integer
+       | (Float other) -> Float
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpSub[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -298,10 +292,9 @@ class Integer < Numeric
   #      4 / Rational(3, 1) # => (4/3)
   #      4 / Complex(3, 0)  # => ((4/3)+0i)
   #
-  def /: (Integer) -> Integer
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Complex) -> Complex
+  def /: (Integer other) -> Integer
+       | (Float other) -> Float
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpDiv[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -317,7 +310,9 @@ class Integer < Numeric
   #
   #     Raises an exception if the comparison cannot be made.
   #
-  def <: (Numeric) -> bool
+  def <: (Integer other) -> bool
+       | (Float other) -> bool
+       | [X] (Numeric::_Coerce[self, Numeric::_OpLt[X], X] other) -> bool
 
   # <!--
   #   rdoc-file=numeric.c
@@ -334,7 +329,7 @@ class Integer < Numeric
   #
   # Related: Integer#>>.
   #
-  def <<: (int) -> Integer
+  def <<: (int count) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -351,7 +346,9 @@ class Integer < Numeric
   #
   # Raises an exception if the comparison cannot be made.
   #
-  def <=: (Numeric) -> bool
+  def <=: (Integer other) -> bool
+        | (Float other) -> bool
+        | [X] (Numeric::_Coerce[self, Numeric::_OpLe[X], X] other) -> bool
 
   # <!--
   #   rdoc-file=numeric.c
@@ -378,8 +375,8 @@ class Integer < Numeric
   #
   # This method is the basis for comparisons in module Comparable.
   #
-  def <=>: (Integer | Rational) -> Integer
-         | (untyped) -> Integer?
+  def <=>: (Integer | Float | Rational other) -> (-1 | 0 | 1)
+         | (untyped) -> (-1 | 0 | 1)?
 
   # <!-- rdoc-file=numeric.c -->
   # Returns `true` if `self` is numerically equal to `other`; `false` otherwise.
@@ -389,7 +386,7 @@ class Integer < Numeric
   #
   # Related: Integer#eql? (requires `other` to be an Integer).
   #
-  def ==: (untyped) -> bool
+  def ==: (untyped other) -> bool
 
   # <!--
   #   rdoc-file=numeric.c
@@ -402,7 +399,7 @@ class Integer < Numeric
   #
   # Related: Integer#eql? (requires `other` to be an Integer).
   #
-  def ===: (untyped) -> bool
+  alias === ==
 
   # <!--
   #   rdoc-file=numeric.c
@@ -418,7 +415,9 @@ class Integer < Numeric
   #
   #     Raises an exception if the comparison cannot be made.
   #
-  def >: (Numeric) -> bool
+  def >: (Integer other) -> bool
+       | (Float other) -> bool
+       | [X] (Numeric::_Coerce[self, Numeric::_OpGt[X], X] other) -> bool
 
   # <!--
   #   rdoc-file=numeric.c
@@ -435,7 +434,9 @@ class Integer < Numeric
   #
   # Raises an exception if the comparison cannot be made.
   #
-  def >=: (Numeric) -> bool
+  def >=: (Integer other) -> bool
+        | (Float other) -> bool
+        | [X] (Numeric::_Coerce[self, Numeric::_OpGe[X], X] other) -> bool
 
   # <!--
   #   rdoc-file=numeric.c
@@ -452,7 +453,7 @@ class Integer < Numeric
   #
   # Related: Integer#<<.
   #
-  def >>: (int) -> Integer
+  def >>: (int count) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -492,9 +493,8 @@ class Integer < Numeric
   #
   # Raises an exception if the slice cannot be constructed.
   #
-  def []: (int) -> Integer
-        | (int i, int len) -> Integer
-        | (Range[int]) -> Integer
+  def []: (int offset, ?int size) -> Integer
+        | (range[int] range) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -509,7 +509,8 @@ class Integer < Numeric
   #
   # Related: Integer#& (bitwise AND), Integer#| (bitwise OR).
   #
-  def ^: (Integer) -> Integer
+  def ^: (Integer other) -> Integer
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpXor[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -523,8 +524,6 @@ class Integer < Numeric
   #
   def abs: () -> Integer
 
-  def abs2: () -> Integer
-
   # <!--
   #   rdoc-file=numeric.c
   #   - allbits?(mask) -> true or false
@@ -548,8 +547,6 @@ class Integer < Numeric
   #
   def allbits?: (int mask) -> bool
 
-  def angle: () -> (Integer | Float)
-
   # <!--
   #   rdoc-file=numeric.c
   #   - anybits?(mask) -> true or false
@@ -573,8 +570,6 @@ class Integer < Numeric
   #
   def anybits?: (int mask) -> bool
 
-  alias arg angle
-
   # <!--
   #   rdoc-file=numeric.rb
   #   - bit_length -> integer
@@ -640,8 +635,7 @@ class Integer < Numeric
   #
   # Related: Integer#floor.
   #
-  def ceil: () -> Integer
-          | (int digits) -> (Integer | Float)
+  def ceil: (?int digits) -> Integer
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -660,6 +654,7 @@ class Integer < Numeric
   #     3.ceildiv(1.2) # => 3
   #
   def ceildiv: (Numeric other) -> Integer
+             | [X, Y] (Numeric::_Coerce[0, Numeric::_OpSub[X, Numeric::_Coerce[self, Numeric::_Div[Y], Y]], X] other) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -679,7 +674,7 @@ class Integer < Numeric
   #
   # Related: Integer#ord.
   #
-  def chr: (?encoding) -> String
+  def chr: (?encoding enc) -> String
 
   # <!--
   #   rdoc-file=bignum.c
@@ -694,11 +689,8 @@ class Integer < Numeric
   #
   #     (0x3FFFFFFFFFFFFFFF+1).coerce(42)   #=> [42, 4611686018427387904]
   #
-  def coerce: (Numeric) -> [ Numeric, Numeric ]
-
-  def conj: () -> Integer
-
-  def conjugate: () -> Integer
+  def coerce: (Integer other) -> [Integer, self]
+            | (float other) -> [Float, Float]
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -706,7 +698,7 @@ class Integer < Numeric
   # -->
   # Returns `1`.
   #
-  def denominator: () -> Integer
+  def denominator: () -> 1
 
   # <!--
   #   rdoc-file=numeric.c
@@ -721,7 +713,7 @@ class Integer < Numeric
   #
   # Raises an exception if `self` is negative or `base` is less than 2.
   #
-  def digits: (?int base) -> ::Array[Integer]
+  def digits: (?int base) -> Array[Integer]
 
   # <!--
   #   rdoc-file=numeric.c
@@ -739,7 +731,8 @@ class Integer < Numeric
   #
   #     Raises an exception if +numeric+ does not have method +div+.
   #
-  def div: (Numeric) -> Integer
+  def div: (Integer | Float other) -> Integer
+         | [X] (Numeric::_Coerce[self, Numeric::_Div[X], X] other) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -765,9 +758,9 @@ class Integer < Numeric
   #     13.divmod(4.0)            # => [3, 1.0]
   #     13.divmod(Rational(4, 1)) # => [3, (1/1)]
   #
-  def divmod: (Integer) -> [ Integer, Integer ]
-            | (Float) -> [ Float, Float ]
-            | (Numeric) -> [ Numeric, Numeric ]
+  def divmod: (Integer other) -> [Integer, Integer]
+            | (float other) -> [Float, Float]
+            | [X, R] (Numeric::_Coerce[self, Numeric::_Divmod[X, R], X] other) -> [Integer, R]
 
   # <!--
   #   rdoc-file=numeric.c
@@ -787,12 +780,11 @@ class Integer < Numeric
   #
   # With no block given, returns an Enumerator.
   #
-  def downto: (Numeric limit) { (Integer) -> void } -> Integer
-            | (Numeric limit) -> ::Enumerator[Integer, self]
-
-  def dup: () -> self
-
-  def eql?: (untyped) -> bool
+  def downto: (Integer | Float limit) -> Enumerator[Integer, self]
+            | (Integer | Float limit) { (Integer i) -> void } -> self
+            | [X] (Numeric::_Coerce[self, Numeric::_OpLt[X], X] &
+                   Numeric::_OpSub[Integer, Numeric::_Div[Integer, Numeric::_OpAdd[Integer, int]]] limit) -> Enumerator[Integer, self]
+            | [X] (Numeric::_Coerce[self, Numeric::_OpLt[X], X] limit) { (Integer i) -> void } -> Integer
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -816,9 +808,8 @@ class Integer < Numeric
   #
   # Raises an exception if `numeric` cannot be converted to a Float.
   #
-  def fdiv: (Numeric) -> Float
-
-  def finite?: () -> bool
+  def fdiv: (Numeric other) -> Float
+          | [X] (Numeric::_Coerce[self, Numeric::_OpDiv[X, float], X] other) -> Float
 
   # <!--
   #   rdoc-file=numeric.c
@@ -856,7 +847,7 @@ class Integer < Numeric
   #     3.gcd(-7)                   #=> 1
   #     ((1<<31)-1).gcd((1<<61)-1)  #=> 1
   #
-  def gcd: (Integer) -> Integer
+  def gcd: (Integer other_int) -> Integer
 
   # <!--
   #   rdoc-file=rational.c
@@ -870,15 +861,7 @@ class Integer < Numeric
   #     3.gcdlcm(-7)                   #=> [1, 21]
   #     ((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]
   #
-  def gcdlcm: (Integer) -> [ Integer, Integer ]
-
-  def i: () -> Complex
-
-  def imag: () -> Integer
-
-  def imaginary: () -> Integer
-
-  def infinite?: () -> Integer?
+  def gcdlcm: (Integer other_int) -> [Integer, Integer]
 
   # <!-- rdoc-file=numeric.c -->
   # Returns a string containing the place-value representation of `self` in radix
@@ -916,14 +899,14 @@ class Integer < Numeric
   #     3.lcm(-7)                   #=> 21
   #     ((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297
   #
-  def lcm: (Integer) -> Integer
+  def lcm: (Integer other_int) -> Integer
 
   # <!--
   #   rdoc-file=numeric.rb
   #   - magnitude()
   # -->
   #
-  def magnitude: () -> Integer
+  alias magnitude abs
 
   # <!-- rdoc-file=numeric.c -->
   # Returns `self` modulo `other` as a real number.
@@ -951,8 +934,6 @@ class Integer < Numeric
   #
   alias modulo %
 
-  def negative?: () -> bool
-
   # <!-- rdoc-file=numeric.c -->
   # Returns the successor integer of `self` (equivalent to `self + 1`):
   #
@@ -961,7 +942,7 @@ class Integer < Numeric
   #
   # Related: Integer#pred (predecessor value).
   #
-  def next: () -> Integer
+  alias next succ
 
   # <!--
   #   rdoc-file=numeric.c
@@ -986,15 +967,13 @@ class Integer < Numeric
   #
   def nobits?: (int mask) -> bool
 
-  def nonzero?: () -> self?
-
   # <!--
   #   rdoc-file=numeric.rb
   #   - numerator -> self
   # -->
   # Returns `self`.
   #
-  def numerator: () -> Integer
+  def numerator: () -> self
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1010,13 +989,7 @@ class Integer < Numeric
   # -->
   # Returns `self`; intended for compatibility to character literals in Ruby 1.9.
   #
-  def ord: () -> Integer
-
-  alias phase angle
-
-  def polar: () -> [ Integer, Integer | Float ]
-
-  def positive?: () -> bool
+  def ord: () -> self
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1028,11 +1001,10 @@ class Integer < Numeric
   #     a.pow(b)     #=> same as a**b
   #     a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values
   #
-  def pow: (Integer other) -> (Integer | Rational)
-         | (Integer other, Integer modulo) -> Integer
-         | (Float) -> (Float | Complex)
-         | (Rational) -> (Float | Rational | Complex)
-         | (Complex) -> Complex
+  def pow: (Integer power, Integer base) -> Integer
+         | (Integer other) -> (Integer | Rational)
+         | (Float other) -> (Float | Complex)
+         | [X, R] (Numeric::_Coerce[self, Numeric::_OpPow[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1047,12 +1019,6 @@ class Integer < Numeric
   #
   def pred: () -> Integer
 
-  def quo: (Integer) -> Rational
-         | (Float) -> Float
-         | (Rational) -> Rational
-         | (Complex) -> Complex
-         | (Numeric) -> Numeric
-
   # <!--
   #   rdoc-file=rational.c
   #   - int.rationalize([eps])  ->  rational
@@ -1060,15 +1026,7 @@ class Integer < Numeric
   # Returns the value as a rational.  The optional argument `eps` is always
   # ignored.
   #
-  def rationalize: (?Numeric eps) -> Rational
-
-  def real: () -> self
-
-  def real?: () -> true
-
-  def rect: () -> [ Integer, Numeric ]
-
-  alias rectangular rect
+  def rationalize: (?untyped _ignored_eps) -> Rational
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1091,10 +1049,10 @@ class Integer < Numeric
   #     13.remainder(4.0)            # => 1.0
   #     13.remainder(Rational(4, 1)) # => (1/1)
   #
-  def remainder: (Integer) -> Integer
-               | (Float) -> Float
-               | (Rational) -> Rational
-               | (Numeric) -> Numeric
+  def remainder: (Integer other) -> Integer
+               | (Float other) -> Float
+               | (Rational other) -> Rational
+               | [X, R]((Numeric::_Coerce[self, Numeric::_OpMod[X, R], X] & Numeric::_OpLt[0] & Numeric::_OpGt[0]) other) -> R
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1142,8 +1100,7 @@ class Integer < Numeric
   #
   # Related: Integer#truncate.
   #
-  def round: (?half: :up | :down | :even) -> Integer
-           | (int digits, ?half: :up | :down | :even) -> (Integer | Float)
+  def round: (?int digits, ?half: Numeric::round_half) -> Integer
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1161,17 +1118,6 @@ class Integer < Numeric
   #
   def size: () -> Integer
 
-  def step: () { (Integer) -> void } -> void
-          | (Numeric limit, ?Integer step) { (Integer) -> void } -> void
-          | (Numeric limit, ?Numeric step) { (Numeric) -> void } -> void
-          | (to: Numeric, ?by: Integer) { (Integer) -> void } -> void
-          | (by: Numeric, ?to: Numeric) { (Numeric) -> void } -> void
-          | () -> Enumerator[Integer, bot]
-          | (Numeric limit, ?Integer step) -> Enumerator[Integer, void]
-          | (Numeric limit, ?Numeric step) -> Enumerator[Numeric, void]
-          | (to: Numeric, ?by: Integer) -> Enumerator[Integer, void]
-          | (by: Numeric, ?to: Numeric) -> Enumerator[Numeric, void]
-
   # <!--
   #   rdoc-file=numeric.c
   #   - succ -> next_integer
@@ -1198,10 +1144,8 @@ class Integer < Numeric
   #
   # With no block given, returns an Enumerator.
   #
-  def times: () { (Integer) -> void } -> self
-           | () -> ::Enumerator[Integer, self]
-
-  def to_c: () -> Complex
+  def times: () -> Enumerator[Integer, self]
+           | () { (Integer i) -> void } -> self
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1225,7 +1169,7 @@ class Integer < Numeric
   # -->
   # Returns `self` (which is already an Integer).
   #
-  def to_i: () -> Integer
+  def to_i: () -> self
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1233,7 +1177,7 @@ class Integer < Numeric
   # -->
   # Returns `self` (which is already an Integer).
   #
-  alias to_int to_i
+  def to_int: () -> self
 
   # <!--
   #   rdoc-file=rational.c
@@ -1263,43 +1207,7 @@ class Integer < Numeric
   #
   # Raises an exception if `base` is out of range.
   #
-  def to_s: () -> String
-          | (2) -> String
-          | (3) -> String
-          | (4) -> String
-          | (5) -> String
-          | (6) -> String
-          | (7) -> String
-          | (8) -> String
-          | (9) -> String
-          | (10) -> String
-          | (11) -> String
-          | (12) -> String
-          | (13) -> String
-          | (14) -> String
-          | (15) -> String
-          | (16) -> String
-          | (17) -> String
-          | (18) -> String
-          | (19) -> String
-          | (20) -> String
-          | (21) -> String
-          | (22) -> String
-          | (23) -> String
-          | (24) -> String
-          | (25) -> String
-          | (26) -> String
-          | (27) -> String
-          | (28) -> String
-          | (29) -> String
-          | (30) -> String
-          | (31) -> String
-          | (32) -> String
-          | (33) -> String
-          | (34) -> String
-          | (35) -> String
-          | (36) -> String
-          | (int base) -> String
+  def to_s: (?int base) -> String
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1322,8 +1230,7 @@ class Integer < Numeric
   #
   # Related: Integer#round.
   #
-  def truncate: () -> Integer
-              | (int ndigits) -> Integer
+  def truncate: (?int ndigits) -> Integer
 
   # <!--
   #   rdoc-file=numeric.c
@@ -1343,8 +1250,10 @@ class Integer < Numeric
   #
   # With no block given, returns an Enumerator.
   #
-  def upto: (Numeric limit) { (Integer) -> void } -> Integer
-          | (Numeric limit) -> ::Enumerator[Integer, self]
+  def upto: (Integer | Float limit) -> Enumerator[Integer, self]
+          | (Integer | Float limit) { (Integer i) -> void } -> self
+          | [X] (Numeric::_Coerce[self, Numeric::_OpGt[X], X] limit) -> Enumerator[Integer, self]
+          | [X] (Numeric::_Coerce[self, Numeric::_OpGt[X], X] limit) { (Integer i) -> void } -> Integer
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1367,7 +1276,8 @@ class Integer < Numeric
   #
   # Related: Integer#& (bitwise AND), Integer#^ (bitwise EXCLUSIVE OR).
   #
-  def |: (Integer) -> Integer
+  def |: (Integer other) -> Integer
+       | [X, R] (Numeric::_Coerce[self, Numeric::_OpOr[X, R], X] other) -> R
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1382,4 +1292,92 @@ class Integer < Numeric
   #     sprintf("%X", ~0x1122334455)    # => "..FEEDDCCBBAA"
   #
   def ~: () -> Integer
+
+  %a{steep:deprecated}
+  def +@: () -> Integer
+
+  %a{steep:deprecated}
+  def abs2: () -> Integer
+
+  %a{steep:deprecated}
+  def angle: () -> (Integer | Float)
+
+  %a{steep:deprecated}
+  alias arg angle
+
+  %a{steep:deprecated}
+  def conj: () -> Integer
+
+  %a{steep:deprecated}
+  def conjugate: () -> Integer
+
+  %a{steep:deprecated}
+  def dup: () -> self
+
+  %a{steep:deprecated}
+  def eql?: (untyped) -> bool
+
+  %a{steep:deprecated}
+  def finite?: () -> bool
+
+  %a{steep:deprecated}
+  def i: () -> Complex
+
+  %a{steep:deprecated}
+  def imag: () -> Integer
+
+  %a{steep:deprecated}
+  def imaginary: () -> Integer
+
+  %a{steep:deprecated}
+  def infinite?: () -> Integer?
+
+  %a{steep:deprecated}
+  def negative?: () -> bool
+
+  %a{steep:deprecated}
+  def nonzero?: () -> self?
+
+  %a{steep:deprecated}
+  alias phase angle
+
+  %a{steep:deprecated}
+  def polar: () -> [ Integer, Integer | Float ]
+
+  %a{steep:deprecated}
+  def positive?: () -> bool
+
+  %a{steep:deprecated}
+  def quo: (Integer) -> Rational
+         | (Float) -> Float
+         | (Rational) -> Rational
+         | (Complex) -> Complex
+         | (Numeric) -> Numeric
+
+  %a{steep:deprecated}
+  def real: () -> self
+
+  %a{steep:deprecated}
+  def real?: () -> true
+
+  %a{steep:deprecated}
+  def rect: () -> [ Integer, Numeric ]
+
+  %a{steep:deprecated}
+  alias rectangular rect
+
+  %a{steep:deprecated}
+  def step: () { (Integer) -> void } -> void
+          | (Numeric limit, ?Integer step) { (Integer) -> void } -> void
+          | (Numeric limit, ?Numeric step) { (Numeric) -> void } -> void
+          | (to: Numeric, ?by: Integer) { (Integer) -> void } -> void
+          | (by: Numeric, ?to: Numeric) { (Numeric) -> void } -> void
+          | () -> Enumerator[Integer, bot]
+          | (Numeric limit, ?Integer step) -> Enumerator[Integer, void]
+          | (Numeric limit, ?Numeric step) -> Enumerator[Numeric, void]
+          | (to: Numeric, ?by: Integer) -> Enumerator[Integer, void]
+          | (by: Numeric, ?to: Numeric) -> Enumerator[Numeric, void]
+
+  %a{steep:deprecated}
+  def to_c: () -> Complex
 end
diff --git a/core/numeric.rbs b/core/numeric.rbs
index 613144948..c788606d8 100644
--- a/core/numeric.rbs
+++ b/core/numeric.rbs
@@ -162,6 +162,115 @@
 class Numeric
   include Comparable
 
+  # Type alias for the `half` parameter in `round` functions.
+  type round_half = string | :up | :down | :even | 'up' | 'down' | 'even'
+
+  # Interface which indicates a type implements ruby's coercion scheme.
+  #
+  # The `coerce` method is only used in the stdlib of Ruby when an operator (such as `Integer#+`)
+  # doesn't know how to handle the second argument. Instead, `other_arg.coerce(the_integer)` is
+  # called, and then operation is then run on the two return arguments (`equiv_self + equiv_other`).
+  #
+  # Traditionally, `_Coerce` functions return a tuple of `[MyClass.new(...), self]`, this is not
+  # a strict requirement, and there are cases where it's useful to return other types. As such,
+  # three generics are required to represent `_Coerce`.
+  interface _Coerce[Other, EquivOther, EquivSelf]
+    # Coerce `other` and `self` into types where the original operation can be performed.
+    # 
+    # See `_Coerce` for more details.
+    def coerce: (Other other) -> [EquivOther, EquivSelf]
+  end
+
+  # Adds an `Other` to `self`, returning a `Return`.
+  interface _OpAdd[Other, Return]
+    # Performs the addition.
+    def +: (Other other) -> Return
+  end
+
+  # Subtracts an `Other` from `self`, returning a `Return`.
+  interface _OpSub[Other, Return]
+    # Performs the subtraction.
+    def -: (Other other) -> Return
+  end
+
+  # Multiplies `self` by an `Other`, returning a `Return`.
+  interface _OpMul[Other, Return]
+    # Performs the multiplication.
+    def *: (Other other) -> Return
+  end
+
+  # Divides `self` by an `Other`, returning a `Return`.
+  interface _OpDiv[Other, Return]
+    # Performs the division.
+    def /: (Other other) -> Return
+  end
+
+  # Modulos `self` by an `Other`, returning a `Return`.
+  interface _OpMod[Other, Return]
+    # Performs the modulus.
+    def %: (Other other) -> Return
+  end
+
+  # Exponentiates `self` by `Other`, returning a `Return`.
+  interface _OpPow[Other, Return]
+    # Performs the exponentiation.
+    def **: (Other other) -> Return
+  end
+
+  # Performs bitwise AND of `self` and `Other`, returning a `Return`.
+  interface _OpAnd[Other, Return]
+    # Performs the bitwise AND.
+    def &: (Other other) -> Return
+  end
+
+  # Performs bitwise OR of `self` and `Other`, returning a `Return`.
+  interface _OpOr[Other, Return]
+    # Performs the bitwise OR.
+    def |: (Other other) -> Return
+  end
+
+  # Performs bitwise XOR of `self` and `Other`, returning a `Return`.
+  interface _OpXor[Other, Return]
+    # Performs the bitwise XOR.
+    def ^: (Other other) -> Return
+  end
+
+  # Returns whether `self` is less than `Other`.
+  interface _OpLt[Other]
+    # Performs the lesser-than comparison.
+    def <: (Other other) -> bool
+  end
+
+  # Returns whether `self` is less than or equal to `Other`.
+  interface _OpLe[Other]
+    # Performs the lesser-than-or-equal-to comparison.
+    def <=: (Other other) -> bool
+  end
+
+  # Returns whether `self` is greater than `Other`.
+  interface _OpGt[Other]
+    # Performs the greater-than comparison.
+    def >: (Other other) -> bool
+  end
+
+  # Returns whether `self` is greater than or equal to `Other`.
+  interface _OpGe[Other]
+    # Performs the greater-than-or-equal-to comparison.
+    def >=: (Other other) -> bool
+  end
+
+  # Performs integer division of `self` by `Other`.
+  interface _Div[Other]
+    # Performs the integer division.
+    def div: (Other other) -> Integer
+  end
+
+  # Performs integer division of `self` by `Other`, returning the whole part and the `Remainder`.
+  interface _Divmod[Other, Remainder]
+    # Performs the division and modulus.
+    def divmod: (Other other) -> [Integer, Remainder]
+  end
+
   public
 
   # <!--
diff --git a/lib/rbs/unit_test/with_aliases.rb b/lib/rbs/unit_test/with_aliases.rb
index 986ed09cd..85b61b042 100644
--- a/lib/rbs/unit_test/with_aliases.rb
+++ b/lib/rbs/unit_test/with_aliases.rb
@@ -127,7 +127,7 @@ def with_range(start, stop, exclude_end = false)
 
             # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
             # end up using the return value of it. This is to add that in when needed.
-            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
+            defined?(lower.<=>) or def lower.<=>(rhs) = :not_nil
 
             # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
             # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range
diff --git a/test/stdlib/Integer_test.rb b/test/stdlib/Integer_test.rb
index 973885bdb..913827141 100644
--- a/test/stdlib/Integer_test.rb
+++ b/test/stdlib/Integer_test.rb
@@ -1,398 +1,811 @@
 require_relative "test_helper"
 
-class IntegerTest < StdlibTest
-  target Integer
+class IntegerSingletonTest < Test::Unit::TestCase
+  include TestHelper
+
+  testing "singleton(::Integer)"
 
   def test_sqrt
-    Integer.sqrt(4)
-    Integer.sqrt(4.0)
-    Integer.sqrt(4/1r)
-    Integer.sqrt(ToInt.new)
+    with_int do |int|
+      assert_send_type  '(int) -> Integer',
+                        Integer, :sqrt, int
+    end
   end
 
-  def test_modulo
-    3 % 1
-    3 % 1.1
-    3 % 1.5r
-  end
-
-  def test_bitwise_ops
-    3 & 1
-    1 ^ 3
-  end
-
-  def test_calc
-    3 * 1
-    3 * 1.0
-    3 * (1r/3)
-
-    3 - 1
-    3 - 0.1
-    3 - 1r
-    3 - 1.to_c
-
-    1 ** 1
-    2 ** 2.1
-    3 ** 3r
-    3 ** 10.to_c
-
-    3 + 1
-    3 + 1.0
-    3 + (1r/3)
-    3 + 10.to_c
-
-    3 / 1
-    3 / 1.0
-    3 / (1r/3)
-    30 / 10.to_c
-  end
-
-  def test_compare
-    3 < 1
-    3 < 1.0
-    3 < 1r
-
-    1 > 1
-    1 > 1.0
-    1 > 1r
-
-    1 <= 3
-    1 <= 1.3
-    1 <= 3r
-
-    1 >= 3
-    1 >= 1.3
-    1 >= 3r
-
-    1 <=> 1
-    1 <=> 1.0
-    1 <=> 3r
-
-    3 === 3.0
-    3 === ""
-  end
-
-  def test_shift
-    1 << 30
-    1 << 30.to_f
-    1 << ToInt.new
-
-    1 >> 30
-    1 >> 30.to_f
-    1 >> ToInt.new
-  end
-
-  def test_aref
-    3[0]
-    3[0.3]
-    3[ToInt.new]
-
-    3[1,2]
-    3[1...3]
-  end
-
-  def test_to_s
-    1.to_s
-    1.to_s(2)
-    1.to_s(3)
-    1.to_s(4)
-    1.to_s(5)
-    1.to_s(6)
-    1.to_s(7)
-    1.to_s(8)
-    1.to_s(9)
-    1.to_s(10)
-    1.to_s(11)
-    1.to_s(12)
-    1.to_s(13)
-    1.to_s(14)
-    1.to_s(15)
-    1.to_s(16)
-    1.to_s(17)
-    1.to_s(18)
-    1.to_s(19)
-    1.to_s(20)
-    1.to_s(21)
-    1.to_s(22)
-    1.to_s(23)
-    1.to_s(24)
-    1.to_s(25)
-    1.to_s(26)
-    1.to_s(27)
-    1.to_s(28)
-    1.to_s(29)
-    1.to_s(30)
-    1.to_s(31)
-    1.to_s(32)
-    1.to_s(33)
-    1.to_s(34)
-    1.to_s(35)
-    1.to_s(36)
-    30.to_s(ToInt.new)
-  end
-
-  def test_abs_abs2
-    3.abs
-    3.abs2
-  end
+  def test_try_convert
+    with_int do |int|
+      assert_send_type  '(int) -> Integer',
+                        Integer, :try_convert, int
+    end
 
-  def test_allbits?
-    1.allbits?(1)
-    2.allbits?(1)
-    3.allbits?(ToInt.new)
+    with_untyped do |untyped|
+      assert_send_type  '(untyped) -> Integer?',
+                        Integer, :try_convert, untyped
+    end
   end
+end
+
+class IntegerInstanceTest < Test::Unit::TestCase
+  include TestHelper
 
-  def test_angle
-    3.angle()
+  testing "::Integer"
+
+  def with_random_Integers
+    [0, -1, 100, -123, rand(-10000..10000)].each do |integer|
+      yield integer
+    end
+  end
+
+  def with_random_ints(&block)
+    with_random_Integers do |integer|
+      with_int(integer, &block)
+    end
+  end
+
+  def test_op_mod(method: :%)
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, method, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, method, 12.3
+
+      with_coerce self: 'Integer', method: :% do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpMod[Y, Z], Y]) -> Z',
+                          integer, method, coerced
+      end
+    end
+  end
+
+  def test_op_and
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :&, 123
+
+      with_coerce self: 'Integer', method: :& do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpAnd[Y, Z], Y]) -> Z',
+                          integer, :&, coerced
+      end
+    end
+  end
+
+  def test_op_mul
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :*, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :*, 12.3
+      assert_send_type  '(Complex) -> Complex',
+                        integer, :*, 12+3i
+
+      with_coerce self: 'Integer', method: :* do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpMul[Y, Z], Y]) -> Z',
+                          integer, :*, coerced
+      end
+    end
+  end
+
+  def test_op_pow
+    assert_send_type  '(Integer) -> Integer',
+                      123, :**, 2
+    assert_send_type  '(Integer) -> Rational',
+                      123, :**, -2
+    assert_send_type  '(Float) -> Float',
+                      123, :**, 12.3
+    assert_send_type  '(Float) -> Complex',
+                      -123, :**, 0.123
+
+    with_coerce self: 'Integer', method: :** do |coerced|
+      assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpPow[Y, Z], Y]) -> Z',
+                        123, :**, coerced
+    end
+  end
+
+  def test_op_add
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :+, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :+, 12.3
+      assert_send_type  '(Complex) -> Complex',
+                        integer, :+, 12+3i
+
+      with_coerce self: 'Integer', method: :+ do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpAdd[Y, Z], Y]) -> Z',
+                          integer, :+, coerced
+      end
+    end
+  end
+
+  def test_op_sub
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :-, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :-, 12.3
+
+      with_coerce self: 'Integer', method: :- do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpSub[Y, Z], Y]) -> Z',
+                          integer, :-, coerced
+      end
+    end
+  end
+
+  def test_op_uneg
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :-@
+    end
+  end
+
+  def test_op_div
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :/, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :/, 12.3
+
+      with_coerce self: 'Integer', method: :/ do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpDiv[Y, Z], Y]) -> Z',
+                          integer, :/, coerced
+      end
+    end
+  end
+
+  def test_op_lt
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> bool',
+                        integer, :<, 123
+      assert_send_type  '(Float) -> bool',
+                        integer, :<, 12.3
+
+      with_coerce self: 'Integer', method: :<, return_value: integer < 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpLt[Y], Y]) -> bool',
+                          integer, :<, coerced
+      end
+    end
+  end
+
+  def test_op_rsh
+    with_random_Integers do |integer|
+      with_random_ints do |amount|
+        assert_send_type  '(int) -> Integer',
+                          integer, :<<, amount
+      end
+    end
+  end
+
+  def test_op_le
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> bool',
+                        integer, :<=, 123
+      assert_send_type  '(Float) -> bool',
+                        integer, :<=, 12.3
+
+      with_coerce self: 'Integer', method: :<=, return_value: integer <= 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpLe[Y], Y]) -> bool',
+                          integer, :<=, coerced
+      end
+    end
+  end
+
+  def test_op_cmp
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> (-1 | 0 | 1)',
+                        integer, :<=>, 123
+      assert_send_type  '(Float) -> (-1 | 0 | 1)',
+                        integer, :<=>, 12.3
+      assert_send_type  '(Float) -> (-1 | 0 | 1)',
+                        integer, :<=>, 12/3r
+      
+      with_untyped do |untyped|
+        assert_send_type  '(untyped) -> (-1 | 0 | 1)?',
+                          integer, :<=>, untyped
+      end
+    end
+  end
+
+  def test_op_eq(method: :==)
+    with_random_Integers do |integer|
+      with_untyped do |untyped|
+        defined? untyped.== or def untyped.==(r) = true
+
+        assert_send_type  '(untyped) -> bool',
+                          integer, method, untyped
+      end
+    end
+  end
+
+  def test_op_eqq
+    test_op_eq(method: :===)
+  end
+
+  def test_op_gt
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> bool',
+                        integer, :>, 123
+      assert_send_type  '(Float) -> bool',
+                        integer, :>, 12.3
+
+      with_coerce self: 'Integer', method: :>, return_value: integer > 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGt[Y], Y]) -> bool',
+                          integer, :>, coerced
+      end
+    end
+  end
+
+  def test_op_ge
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> bool',
+                        integer, :>=, 123
+      assert_send_type  '(Float) -> bool',
+                        integer, :>=, 12.3
+
+      with_coerce self: 'Integer', method: :>=, return_value: integer >= 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGe[Y], Y]) -> bool',
+                          integer, :>=, coerced
+      end
+    end
+  end
+
+  def test_op_lsh
+    with_random_Integers do |integer|
+      with_random_ints do |amount|
+        assert_send_type  '(int) -> Integer',
+                          integer, :<<, amount
+      end
+    end
+  end
+
+  def test_op_aref
+    with_random_Integers do |integer|
+      with_random_ints do |offset|
+        assert_send_type  '(int) -> Integer',
+                          integer, :[], offset
+
+        with_random_ints do |size|
+          assert_send_type  '(int, int) -> Integer',
+                            integer, :[], offset, size
+        end
+      end
+
+      with_random_Integers do |start|
+        with_random_Integers do |stop|
+          with_range with_int(start), with_int(stop) do |range|
+            # `Integer#[]` specifically requires `range.begin` to also define `<=>`, whereas
+            # Normally `<=>` is only required on `range.end`, so we have to add it here.
+            #
+            # It's not actually shown in the type definition because it's a bit too verbose.
+            defined? range.begin.<=> or def (range.begin).<=>(other) = 123
+
+            assert_send_type  '(range[int]) -> Integer',
+                              integer, :[], range
+          end
+        end
+      end
+    end
+  end
+
+  def test_op_xor
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :^, 123
+
+      with_coerce self: 'Integer', method: :^ do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpXor[Y, Z], Y]) -> Z',
+                          integer, :^, coerced
+      end
+
+    end
+  end
+
+  def test_abs(method: :abs)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, method
+    end
   end
 
-  def test_anybits?
-    0xf0.anybits?(0xf)
-    0xf1.anybits?(0xf)
-    0xf1.anybits?(ToInt.new)
+  def test_allbits?
+    with_random_Integers do |integer|
+      with_random_ints do |mask|
+        assert_send_type  '(int) -> bool',
+                          integer, :allbits?, mask
+      end
+    end
   end
 
-  def test_arg
-    3.arg
+  def test_anybits?
+    with_random_Integers do |integer|
+      with_random_ints do |mask|
+        assert_send_type  '(int) -> bool',
+                          integer, :anybits?, mask
+      end
+    end
   end
 
   def test_bit_length
-    3.bit_length
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :bit_length
+    end
   end
 
   def test_ceil
-    3.ceil
-    3.ceil(10)
-    3.ceil(ToInt.new)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :ceil
+
+      with_random_ints do |digits|
+        assert_send_type  '(int) -> Integer',
+                          integer, :ceil, digits
+      end
+    end
   end
 
   def test_ceildiv
-    3.ceildiv(10)
-    3.ceildiv(1.3)
+    with_random_Integers do |integer|
+  # def ceildiv: (Numeric other) -> Integer
+  #            | [X, Y] (Numeric::_Coerce[0, Numeric::_OpSub[X, Numeric::_Coerce[self, Numeric::_Div[Y], Y]], X] other) -> Integer
+
+    end
   end
 
   def test_chr
-    3.chr
-    3.chr(Encoding::UTF_8)
-    3.chr("UTF-7")
-    3.chr(ToStr.new("ASCII-8BIT"))
-  end
+    assert_send_type  '() -> String',
+                      'a'.ord, :chr
 
-  def test_conj
-    3.conj
+    with_encoding do |enc|
+      assert_send_type  '(encoding) -> String',
+                        'a'.ord, :chr, enc
+    end
   end
 
-  def test_conjugate
-    3.conjugate
+  def test_coerce
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> [Integer, Integer]',
+                        integer, :coerce, 123
+      
+      with_float do |float|
+        assert_send_type  '(float) -> [Float, Float]',
+                          integer, :coerce, float
+      end
+    end
   end
 
   def test_denominator
-    3.denominator
+    assert_send_type  '() -> 1',
+                      123, :denominator
   end
 
   def test_digits
-    3.digits
-    3.digits(3)
-    3.digits(3.0)
-    30.digits(ToInt.new)
-  end
-
-  def test_div
-    30.div(10)
-  end
+    with_random_Integers do |integer|
+      integer = integer.abs # to prevent exceptions
 
-  def test_div_mod
-    3.divmod(3)
-    40.divmod(1.0)
-    30.divmod(30r)
-  end
+      assert_send_type  '() -> Array[Integer]',
+                        integer, :digits
 
-  def test_down_to
-    30.downto(1) {}
-    30.downto(31)
-    30.downto(4.2)
+      with_int 16 do |base|
+        assert_send_type  '(int) -> Array[Integer]',
+                          integer, :digits, base
+      end
+    end
   end
 
-  def test_eql?
-    1.eql?("")
-    3.eql?(1.0)
+  def test_div
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :div, 123
+      assert_send_type  '(Float) -> Integer',
+                        integer, :div, 12.3
+
+      with_coerce self: 'Integer', method: :div, return_value: 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_Div[Y], Y]) -> Integer',
+                          integer, :div, coerced
+      end
+    end
+  end
+
+  def test_divmod
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :div, 123
+      assert_send_type  '(Float) -> Integer',
+                        integer, :div, 12.3
+
+      with_coerce self: 'Integer', method: :div, return_value: 12 do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_Div[Y], Y]) -> Integer',
+                          integer, :div, coerced
+      end
+    end
+  end
+
+  def test_downto
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Enumerator[Integer, Integer]',
+                        integer, :downto, 123
+      assert_send_type  '(Float) -> Enumerator[Integer, Integer]',
+                        integer, :downto, 12.3
+      assert_send_type  '(Integer) { (Integer) -> void } -> Integer',
+                        integer, :downto, 123 do |_| end
+      assert_send_type  '(Float) { (Integer) -> void } -> Integer',
+                        integer, :downto, 12.3 do |_| end
+
+      # Can't use `with_coerce` cause we have to dynamically create the `equiv_self`
+      coerced = BlankSlate.new.__with_object_methods(:define_singleton_method)
+      eq_self = BlankSlate.new.__with_object_methods(:equal?, :__id__)
+
+      assert_fn = method(:assert)
+      coerced.define_singleton_method :coerce do |limit|
+        eq_other = BlankSlate.new.__with_object_methods(:define_singleton_method)
+        eq_other.define_singleton_method :< do |r|
+          assert_fn.call eq_self.equal? r
+          limit < 10
+        end
+
+        [eq_other, eq_self]
+      end
+
+      assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGe[Y], Y] limit) { (Integer) -> void } -> Integer',
+                        integer, :downto, coerced do |i| end
+      
+      coerced.define_singleton_method :- do |other|
+        assert_fn.call Integer === other
+
+        has_div = BlankSlate.new.__with_object_methods(:define_singleton_method)
+        has_div.define_singleton_method :div do |other|
+          assert_fn.call Integer === other
+
+          has_add = BlankSlate.new.__with_object_methods(:define_singleton_method)
+          has_add.define_singleton_method :+ do |other|
+            assert_fn.call Integer === other
+            x = ToInt.new(12)
+            def x.==(r) = false # We just need this for the unit test harness
+            x
+          end
+
+          has_add
+        end
+
+        has_div
+      end
+
+      assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGe[Y], Y] &
+                              Numeric::_OpSub[Integer, Numeric::_Div[Integer, Numeric::_OpAdd[Integer, int]]] limit) -> Enumerator[Integer, Integer]',
+                        integer, :downto, coerced
+    end
   end
 
   def test_even?
-    30.even?
+    with_random_Integers do |integer|
+      assert_send_type  '() -> bool',
+                        integer, :even?
+    end
   end
 
   def test_fdiv
-    30.fdiv(30)
-    30.fdiv(3r)
-    30.fdiv(3.1)
-  end
-
-  def test_finite?
-    30.finite?
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Float',
+                        integer, :fdiv, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :fdiv, 12.3
+      assert_send_type  '(Numeric) -> Float',
+                        integer, :fdiv, Class.new(Numeric){ def to_f = 12.3 }.new
+
+      with_coerce(
+        self: 'Integer',
+        method: :fdiv,
+        return_value: ToF.new(12.3)
+      ) do |coerced|
+        assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpDiv[Y, float], Y]) -> Float',
+                          integer, :fdiv, coerced
+      end
+    end
   end
 
   def test_floor
-    30.floor
-    30.floor(3)
-    30.floor(ToInt.new)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :floor
+
+      with_random_ints do |digits|
+        assert_send_type  '(int) -> Integer',
+                          integer, :floor, digits
+      end
+    end
   end
 
   def test_gcd
-    30.gcd(1)
+    with_random_Integers do |integer|
+      with_random_Integers do |other_int|
+        assert_send_type  '(Integer) -> Integer',
+                          integer, :gcd, other_int
+      end
+    end
   end
 
   def test_gcdlcm
-    30.gcdlcm(31)
+    with_random_Integers do |integer|
+      with_random_Integers do |other_int|
+        assert_send_type  '(Integer) -> [Integer, Integer]',
+                          integer, :gcdlcm, other_int
+      end
+    end
   end
 
-  def test_infinite?
-    30.infinite?
+  def test_inspect
+    test_to_s(method: :to_s)
+  end
+
+  def test_integer?
+    assert_send_type  '() -> true',
+                      123, :integer?
   end
 
   def test_lcm
-    30.lcm(50)
+    with_random_Integers do |integer|
+      with_random_Integers do |other_int|
+        assert_send_type  '(Integer) -> Integer',
+                          integer, :lcm, other_int
+      end
+    end
   end
 
   def test_magnitude
-    30.magnitude
+    test_abs(method: :magnitude)
   end
 
-  def test_modulo_
-    30.modulo(30)
-    30.modulo(3.1)
-    30.modulo(3r/5)
+  def test_modulo
+    test_op_mod(method: :modulo)
   end
 
   def test_next
-    30.next
+    test_succ(method: :next)
   end
 
   def test_nobits?
-    0xf0.nobits?(0xf)
-    0xf1.nobits?(0xf)
-    30.nobits?(ToInt.new)
+    with_random_Integers do |integer|
+      with_random_ints do |mask|
+        assert_send_type  '(int) -> bool',
+                          integer, :nobits?, mask
+      end
+    end
   end
 
-  def test_nonzero?
-    30.nonzero?
-    0.nonzero?
+  def test_numerator
+    assert_send_type  '() -> Integer',
+                      123, :numerator
   end
 
-  def test_numerator
-    30.numerator
+  def test_odd?
+    with_random_Integers do |integer|
+      assert_send_type  '() -> bool',
+                        integer, :odd?
+    end
   end
 
-  def test_pow
-    1.pow(30)
-    1.pow(2.0)
-    1.pow(30.to_c)
-    3.pow(3, 5)
+  def test_ord
+    assert_send_type  '() -> Integer',
+                      123, :ord
   end
 
-  def test_quo
-    3.quo(1)
-    3.quo(2.1)
-    3.quo(4r/5)
-    3.quo(10.to_c)
+  def test_pow
+    assert_send_type  '(Integer, Integer) -> Integer',
+                      123, :pow, 2, 3
+    refute_send_type  '(int, Integer) -> Integer',
+                      123, :pow, ToInt.new(2), 3
+    refute_send_type  '(Integer, int) -> Integer',
+                      123, :pow, 2, ToInt.new(3)
+
+    assert_send_type  '(Integer) -> Integer',
+                      123, :pow, 2
+    assert_send_type  '(Integer) -> Rational',
+                      123, :pow, -2
+    assert_send_type  '(Float) -> Float',
+                      123, :pow, 12.3
+    assert_send_type  '(Float) -> Complex',
+                      -123, :pow, 0.123
+
+    with_coerce self: 'Integer', method: :** do |coerced|
+      assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpPow[Y, Z], Y]) -> Z',
+                        123, :pow, coerced
+    end
+  end
+
+  def test_pred
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :pred
+    end
   end
 
   def test_rationalize
-    3.rationalize
-    3.rationalize(30)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Rational',
+                        integer, :rationalize
+
+      with_untyped do |untyped|
+        assert_send_type  '(untyped) -> Rational',
+                          integer, :rationalize, untyped
+      end
+    end
   end
 
   def test_remainder
-    3.remainder(1)
-    3.remainder(1.3)
-    3.remainder(1r/3)
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :remainder, 123
+      assert_send_type  '(Float) -> Float',
+                        integer, :remainder, 12.3
+      assert_send_type  '(Rational) -> Rational',
+                        integer, :remainder, 12r
+
+      coerced = BlankSlate.new.__with_object_methods(:define_singleton_method)
+      equiv_self = BlankSlate.new.__with_object_methods(:__id__)
+      equiv_other = BlankSlate.new.__with_object_methods(:define_singleton_method, :__id__)
+      ret = BlankSlate.new.__with_object_methods(:==)
+      assert_fn = method(:assert)
+
+      coerced.define_singleton_method :coerce do |other|
+        assert_fn.call integer.equal? other
+        [equiv_other, equiv_self]
+      end
+
+      equiv_other.define_singleton_method :% do |other|
+        assert_fn.call equiv_self.__id__ == other.__id__
+        ret
+      end
+
+      coerced.define_singleton_method :< do |other|
+        assert_fn.call 0.equal? other
+        integer < other
+      end
+
+      coerced.define_singleton_method :> do |other|
+        assert_fn.call 0.equal? other
+        integer > other
+      end
+
+      assert_send_type  '[X, R](Numeric::_Coerce[Integer, Numeric::_OpMod[X, R], X] & Numeric::_OpLt[0] & Numeric::_OpGt[0]) -> R',
+        integer, :remainder, coerced
+    end
   end
 
   def test_round
-    13.round()
-    13.round(half: :up)
-    14.round(-1, half: :down)
-    15.round(ToInt.new)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :round
+
+      with_round_half do |half|
+        assert_send_type  '(half: Numeric::round_half) -> Integer',
+                          integer, :round, half: half
+
+        with_random_ints do |digits|
+          assert_send_type  '(int, half: Numeric::round_half) -> Integer',
+                            integer, :round, digits, half: half
+        end
+      end
+    end
   end
 
-  def test_step
-    3.step { break }
-    3.step
-    3.step(10, 2) {}
-    3.step(10, 2)
-    3.step(10, 1.1) {}
-    3.step(10, 1.1)
+  def test_size
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :size
+    end
+  end
 
-    3.step(to: 30) { break }
-    3.step(to: 30)
-    3.step(to: 30, by: 100) {}
-    3.step(to: 30, by: 100)
-    3.step(to: 30, by: 10.0) {}
-    3.step(to: 30, by: 10.0)
+  def test_succ(method: :succ)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, method
+    end
   end
 
   def test_times
-    3.times {}
-    3.times
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Enumerator[Integer, Integer]',
+                        integer, :times
+      assert_send_type  '() { (Integer) -> void } -> Integer',
+                        integer, :times do |_| end
+    end
   end
 
-  def test_truncate
-    100.truncate
-    100.truncate(10)
-    100.truncate(ToInt.new(-2))
+  def test_to_f
+    assert_send_type  '() -> Float',
+                      123, :to_f
   end
 
-  def test_upto
-    5.upto(10) {}
-    5.upto(10.1) {}
+  def test_to_i
+    assert_send_type  '() -> Integer',
+                      123, :to_i
   end
-end
 
+  def test_to_int
+    assert_send_type  '() -> Integer',
+                      123, :to_int
+  end
 
-class IntegerSingletonTest < Test::Unit::TestCase
-  include TestHelper
+  def test_to_r
+    assert_send_type  '() -> Rational',
+                      123, :to_r
+  end
 
-  testing "singleton(::Integer)"
+  def test_to_s(method: :to_s)
+    with_random_Integers do |integer|
+      assert_send_type  '() -> String',
+                        integer, method
 
-  def test_try_convert
-    assert_send_type(
-      "(Integer) -> Integer",
-      Integer, :try_convert, 10
-    )
-    assert_send_type(
-      "(ToInt) -> Integer",
-      Integer, :try_convert, ToInt.new(10)
-    )
-    assert_send_type(
-      "(String) -> nil",
-      Integer, :try_convert, "10"
-    )
+      with_int 31 do |base|
+        assert_send_type  '(int) -> String',
+                          integer, method, base
+      end
+    end
   end
-end
 
-class IntegerInstanceTest < Test::Unit::TestCase
-  include TestHelper
+  def test_truncate
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        integer, :truncate
 
-  testing "::Integer"
+      with_random_ints do |digits|
+        assert_send_type  '(int) -> Integer',
+                          integer, :truncate, digits
+      end
+    end
+  end
 
-  def test_pow
-    assert_send_type "(Integer) -> Integer",
-                     1, :pow, 2
-    assert_send_type "(Integer) -> Rational",
-                     -2, :pow, -1
-    assert_send_type "(Integer, Integer) -> Integer",
-                     1, :pow, 2, 10
-    assert_send_type "(Float) -> Float",
-                     1, :pow, 1.0
-    assert_send_type "(Float) -> Complex",
-                     -9, :pow, 0.1
-    assert_send_type "(Rational) -> Float",
-                     2, :pow, 1/2r
-    assert_send_type "(Rational) -> Rational",
-                     1, :pow, 1r
-    assert_send_type "(Rational) -> Complex",
-                     -3, :pow, -4/3r
-    assert_send_type "(Complex) -> Complex",
-                     1, :pow, 1i
+  def test_upto
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Enumerator[Integer, Integer]',
+                        integer, :upto, 123
+      assert_send_type  '(Float) -> Enumerator[Integer, Integer]',
+                        integer, :upto, 12.3
+      assert_send_type  '(Integer) { (Integer) -> void } -> Integer',
+                        integer, :upto, 123 do |_| end
+      assert_send_type  '(Float) { (Integer) -> void } -> Integer',
+                        integer, :upto, 12.3 do |_| end
+
+      coerced = BlankSlate.new.__with_object_methods(:define_singleton_method)
+      geq = BlankSlate.new.__with_object_methods(:define_singleton_method)
+
+      coerced.define_singleton_method :coerce do |rhs|
+        [geq, rhs]
+      end
+
+      geq.define_singleton_method :> do |x|
+        integer + 10 > x
+      end
+
+      assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGt[Y], Y] limit) -> Enumerator[Integer, Integer]',
+                        integer, :upto, coerced
+      assert_send_type  '[Y] (Numeric::_Coerce[Integer, Numeric::_OpGt[Y], Y] limit) { (Integer) -> void } -> Integer',
+                        integer, :upto, coerced do |i| end
+    end
+  end
+
+  def test_zero?
+    with_random_Integers do |integer|
+      assert_send_type  '() -> bool',
+                        integer, :zero?
+    end
+  end
+
+  def test_op_or
+    with_random_Integers do |integer|
+      assert_send_type  '(Integer) -> Integer',
+                        integer, :|, 123
+
+      with_coerce self: 'Integer', method: :| do |coerced|
+        assert_send_type  '[Y, Z] (Numeric::_Coerce[Integer, Numeric::_OpOr[Y, Z], Y]) -> Z',
+                          integer, :|, coerced
+      end
+    end
+  end
+
+  def test_op_comp
+    with_random_Integers do |integer|
+      assert_send_type  '() -> Integer',
+                        123, :~@
+    end
   end
 end
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index 1f23d3478..7e720e44f 100644
--- a/test/stdlib/test_helper.rb
+++ b/test/stdlib/test_helper.rb
@@ -51,6 +51,37 @@ def if_ruby31(&block)
 end
 
 module WithStdlibAliases
+  def with_round_half(&block)
+    %i[up down even].each do |val|
+      block.call val
+      with_string(val.to_s, &block)
+    end
+  end
+
+  def with_coerce(self:, method:, return_value: return_value_not_given=true)
+    blankslate = RBS::UnitTest::Convertibles::BlankSlate
+
+    coercer = blankslate.new.__with_object_methods(:define_singleton_method)
+    equiv_other = blankslate.new.__with_object_methods(:define_singleton_method)
+    equiv_self = blankslate.new
+    return_value = blankslate.new if return_value_not_given
+    self_ = binding.local_variable_get(:self)
+
+    assert_type_fn = method(:assert_type)
+    coercer.define_singleton_method :coerce do |other|
+      assert_type_fn.call self_, other
+      [equiv_other, equiv_self]
+    end
+
+    assert_fn = method(:assert)
+    equiv_other.define_singleton_method method do |other|
+      assert_fn.call ::Object.instance_method(:equal?).bind_call(other, equiv_self)
+      return_value
+    end
+
+    yield coercer
+  end
+
   def with_timeout(seconds: 1, nanoseconds: 0)
     unless block_given?    
       return RBS::UnitTest::Convertibles::WithAliases::WithEnum.new(