diff --git a/core/hash.rbs b/core/hash.rbs
index df4bbe6c8..290fb5466 100644
--- a/core/hash.rbs
+++ b/core/hash.rbs
@@ -486,15 +486,29 @@
 # *   #flatten: Returns an array that is a 1-dimensional flattening of `self`.
 # *   #invert: Returns a hash with the each key-value pair inverted.
 #
-class Hash[unchecked out K, unchecked out V] < Object
+class Hash[unchecked out K, unchecked out V]
   include Enumerable[[ K, V ]]
 
+  # Interface that indicates a type can be used as a key to `Hash` lookup methods.
+  #
   interface _Key
     def hash: () -> Integer
 
     def eql?: (untyped rhs) -> boolish
   end
 
+  # Interface that indicates a type convertible to `[ K, V ]` via its `#to_ary` method.
+  #
+  interface _Pair[K, V]
+    def to_ary: () -> [ K, V ]
+  end
+
+  # Interface for comparing equality of types.
+  #
+  interface _Equals
+    def ==: (untyped other) -> boolish
+  end
+
   # <!--
   #   rdoc-file=hash.c
   #   - Hash[] -> new_empty_hash
@@ -525,9 +539,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Raises an exception if the argument list does not conform to any of the above.
   #
-  def self.[]: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
-             | [U, V] (Array[[ U, V ]]) -> ::Hash[U, V]
-             | (*untyped) -> ::Hash[untyped, untyped]
+  def self.[]: [K, V] (hash[K, V] hash) -> instance
+             | [K, V] (array[ _Pair[K, V] ] two_element_arrays) -> instance
+             | [T] (*T objects) -> Hash[T, T]
 
   # <!--
   #   rdoc-file=hash.c
@@ -542,8 +556,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Raises an exception unless `obj.to_hash` returns a `Hash` object.
   #
-  def self.try_convert: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
-                      | (untyped) -> (::Hash[untyped, untyped] | nil)
+  def self.try_convert: [K, V] (hash[K, V] hash) -> Hash[K, V]
+                      | (untyped) -> nil
 
   # <!--
   #   rdoc-file=hash.c
@@ -557,7 +571,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 < h1 # => false
   #     h1 < h1 # => false
   #
-  def <: [A, B] (::Hash[A, B]) -> bool
+  def <: (hash[untyped, untyped] other_hash) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -570,7 +584,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 <= h1 # => false
   #     h1 <= h1 # => true
   #
-  def <=: [A, B] (::Hash[A, B]) -> bool
+  def <=: (hash[untyped, untyped] other_hash) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -604,7 +618,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 > h1 # => false
   #     h1 > h1 # => false
   #
-  def >: [A, B] (::Hash[A, B]) -> bool
+  def >: (hash[untyped, untyped] other_hash) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -617,7 +631,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 >= h1 # => false
   #     h1 >= h1 # => true
   #
-  def >=: [A, B] (::Hash[A, B]) -> bool
+  def >=: (hash[untyped, untyped] other_hash) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -632,7 +646,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h[:nosuch] # => nil
   #
-  def []: %a{implicitly-returns-nil} (K arg0) -> V
+  def []: %a{implicitly-returns-nil} (_Key key) -> V
 
   # <!--
   #   rdoc-file=hash.c
@@ -655,7 +669,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.store(:bat, 3) # => 3
   #     h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
   #
-  def []=: (K arg0, V arg1) -> V
+  def []=: (K key, V value) -> V
 
   # <!--
   #   rdoc-file=hash.c
@@ -686,8 +700,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # Related: Enumerable#any?
   #
   def any?: () -> bool
-          | (untyped pattern) -> bool
-          | () { (K, V) -> boolish } -> bool
+          | (Enumerable::_Pattern pattern) -> bool
+          | () { ([ K, V ] pair) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -700,7 +714,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Returns `nil` if key `key` is not found.
   #
-  def assoc: (K arg0) -> [ K, V ]?
+  def assoc: (_Equals key) -> [ K, V ]?
 
   # <!--
   #   rdoc-file=hash.c
@@ -719,7 +733,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 = h.compact
   #     h1 # => {:foo=>0, :baz=>2}
   #
-  def compact: () -> ::Hash[K, V]
+  def compact: () -> instance
 
   # <!--
   #   rdoc-file=hash.c
@@ -774,7 +788,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #   - deconstruct_keys(p1)
   # -->
   #
-  def deconstruct_keys: (Array[K] | nil) -> self
+  def deconstruct_keys: (untyped) -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -795,7 +809,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h[:foo] = "Hello"
   #     h.default(:foo) # => "No key foo"
   #
-  def default: (?K arg0) -> V?
+  def default: (?_Key key) -> V?
 
   # <!--
   #   rdoc-file=hash.c
@@ -809,7 +823,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # See [Default Values](rdoc-ref:Hash@Default+Values).
   #
-  def default=: (V arg0) -> V
+  def default=: (V default) -> V
 
   # <!--
   #   rdoc-file=hash.c
@@ -822,7 +836,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.default_proc = proc {|hash, key| "Default value for #{key}" }
   #     h.default_proc.class # => Proc
   #
-  def default_proc: () -> (Proc | nil)
+  def default_proc: () -> (^(self, _Key key) -> V)?
 
   # <!--
   #   rdoc-file=hash.c
@@ -837,7 +851,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.default_proc = nil
   #     h.default_proc # => nil
   #
-  def default_proc=: (Proc | _ToProc | nil) -> (Proc | _ToProc | nil)
+  def default_proc=: (nil) -> nil
+                   | (^(self, _Key key) -> V proc) -> ^(self, _Key) -> V
+                   | (_ToProc proc) -> Proc
 
   # <!--
   #   rdoc-file=hash.c
@@ -866,8 +882,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.delete(:nosuch) { |key| "Key #{key} not found" } # => "Key nosuch not found"
   #     h # => {:foo=>0, :bar=>1, :baz=>2}
   #
-  def delete: (K arg0) -> V?
-            | [U] (K arg0) { (K arg0) -> U } -> (U | V)
+  def delete: (_Key key) -> V?
+            | [T, K2 < _Key] (K2 key) { (K2 key) -> T } -> (T | V)
 
   # <!--
   #   rdoc-file=hash.c
@@ -884,8 +900,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.delete_if # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:delete_if>
   #     e.each { |key, value| value > 0 } # => {:foo=>0}
   #
-  def delete_if: () { (K, V) -> boolish } -> self
-               | () -> ::Enumerator[[ K, V ], self]
+  def delete_if: () -> Enumerator[[ K, V ], self]
+               | () { (K key, V value) -> boolish } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -914,7 +930,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.dig(:hello, :world) # => h
   #     h.dig(:hello, :world, :foo, :bar, 2) # => :c
   #
-  def dig: (K, *untyped) -> untyped
+  def dig: (_Key key, *untyped identifiers) -> untyped
 
   # <!-- rdoc-file=hash.c -->
   # Calls the given block with each key-value pair; returns `self`:
@@ -937,8 +953,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     bar: 1
   #     baz: 2
   #
-  def each: () { ([ K, V ] arg0) -> untyped } -> self
-          | () -> ::Enumerator[[ K, V ], self]
+  def each: () -> Enumerator[[ K, V ], self]
+          | () { ([ K, V ] pair) -> void } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -965,8 +981,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     bar
   #     baz
   #
-  def each_key: () { (K arg0) -> untyped } -> ::Hash[K, V]
-              | () -> ::Enumerator[K, self]
+  def each_key: () -> Enumerator[K, self]
+              | () { (K key) -> void } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1022,8 +1038,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     1
   #     2
   #
-  def each_value: () { (V arg0) -> untyped } -> self
-                | () -> ::Enumerator[V, self]
+  def each_value: () -> Enumerator[V, self]
+                | () { (V value) -> void } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1052,7 +1068,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h3 = {baz: 2, bar: 1, foo: 0}
   #     h1.eql? h3 # => true
   #
-  def eql?: (untyped) -> bool
+  def eql?: (untyped object) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -1064,7 +1080,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Any given `keys` that are not found are ignored.
   #
-  def except: (*K) -> ::Hash[K, V]
+  def except: (*_Key keys) -> Hash[K, V]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1088,9 +1104,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # Note that this method does not use the values of either #default or
   # #default_proc.
   #
-  def fetch: (K arg0) -> V
-           | [X] (K arg0, X arg1) -> (V | X)
-           | [X] (K arg0) { (K arg0) -> X } -> (V | X)
+  def fetch: (_Key key) -> V
+           | [T] (_Key key, T default_value) -> (V | T)
+           | [K2 < _Key, T] (K2 key) { (K2 key) -> T } -> (V | T)
 
   # <!--
   #   rdoc-file=hash.c
@@ -1112,10 +1128,14 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # When no block is given, raises an exception if any given key is not found.
   #
-  def fetch_values: (*K) -> ::Array[V]
-                  | [X] (*K) { (K) -> X } -> ::Array[V | X]
+  def fetch_values: (*_Key keys) -> Array[V]
+                  | [K2 < _Key, T] (*K2 keys) { (K2 key) -> T } -> Array[V | T]
 
-  # <!-- rdoc-file=hash.c -->
+  # <!--
+  #   rdoc-file=hash.c
+  #   - hash.select {|key, value| ... } -> new_hash
+  #   - hash.select -> new_enumerator
+  # -->
   # Returns a new `Hash` object whose entries are those for which the block
   # returns a truthy value:
   #     h = {foo: 0, bar: 1, baz: 2}
@@ -1126,10 +1146,14 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.select # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select>
   #     e.each {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
   #
-  def filter: () { (K, V) -> boolish } -> ::Hash[K, V]
-            | () -> ::Enumerator[[ K, V ], ::Hash[K, V]]
+  def select: () -> Enumerator[[ K, V ], Hash[K, V]]
+            | () { (K key, V value) -> boolish } -> Hash[K, V]
 
-  # <!-- rdoc-file=hash.c -->
+  # <!--
+  #   rdoc-file=hash.c
+  #   - hash.select! {|key, value| ... } -> self or nil
+  #   - hash.select! -> new_enumerator
+  # -->
   # Returns `self`, whose entries are those for which the block returns a truthy
   # value:
   #     h = {foo: 0, bar: 1, baz: 2}
@@ -1142,8 +1166,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.select!  # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select!>
   #     e.each { |key, value| value < 2 } # => {:foo=>0, :bar=>1}
   #
-  def filter!: () { (K, V) -> boolish } -> self?
-             | () -> ::Enumerator[[ K, V ], self?]
+  def select!: () -> Enumerator[[ K, V ], self?]
+             | () { (K key, V value) -> boolish } -> self?
 
   # <!--
   #   rdoc-file=hash.c
@@ -1175,14 +1199,14 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.flatten(0) # => [[:foo, 0], [:bar, [:bat, 3]], [:baz, 2]]
   #     h.flatten(0) == h.to_a # => true
   #
-  def flatten: () -> ::Array[K | V]
-             | (1 level) -> ::Array[K | V]
-             | (Integer level) -> Array[untyped]
+  def flatten: (?1 level) -> Array[K | V]
+             | (0 level) -> Array[[K, V]]
+             | (int level) -> Array[untyped]
 
   # <!-- rdoc-file=hash.c -->
   # Returns `true` if `key` is a key in `self`, otherwise `false`.
   #
-  def has_key?: (K arg0) -> bool
+  def has_key?: (_Key key) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -1191,7 +1215,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   # -->
   # Returns `true` if `value` is a value in `self`, otherwise `false`.
   #
-  def has_value?: (V arg0) -> bool
+  def has_value?: (_Equals value) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -1244,7 +1268,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 0, baz: 0}
   #     h.invert # => {0=>:baz}
   #
-  def invert: () -> ::Hash[V, K]
+  def invert: () -> Hash[V, K]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1261,8 +1285,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.keep_if # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:keep_if>
   #     e.each { |key, value| key.start_with?('b') } # => {:bar=>1, :baz=>2}
   #
-  def keep_if: () { (K, V) -> boolish } -> self
-             | () -> ::Enumerator[[ K, V ], self]
+  def keep_if: () -> Enumerator[[ K, V ], self]
+             | () { (K key, V value) -> boolish } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1276,7 +1300,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Returns `nil` if no such value is found.
   #
-  def key: (V) -> K?
+  def key: (_Equals value) -> K?
 
   # <!-- rdoc-file=hash.c -->
   # Returns `true` if `key` is a key in `self`, otherwise `false`.
@@ -1291,14 +1315,18 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.keys # => [:foo, :bar, :baz]
   #
-  def keys: () -> ::Array[K]
+  def keys: () -> Array[K]
 
-  # <!-- rdoc-file=hash.c -->
+  # <!--
+  #   rdoc-file=hash.c
+  #   - hash.length -> integer
+  #   - hash.size -> integer
+  # -->
   # Returns the count of entries in `self`:
   #
   #     {foo: 0, bar: 1, baz: 2}.length # => 3
   #
-  def length: () -> Integer
+  def size: () -> Integer
 
   # <!-- rdoc-file=hash.c -->
   # Returns `true` if `key` is a key in `self`, otherwise `false`.
@@ -1356,8 +1384,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 = h.merge { |key, old_value, new_value| raise 'Cannot happen' }
   #     h1 # => {:foo=>0, :bar=>1, :baz=>2}
   #
-  def merge: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
-           | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> C } -> ::Hash[A | K, B | V | C]
+  def merge: [A, B] (*hash[A, B] other_hashes) -> Hash[A | K, B | V]
+           | [A, B, C] (*hash[A, B] other_hashes) { (K key, V oldval, B newval) -> C } -> Hash[A | K, B | V | C]
 
   # <!-- rdoc-file=hash.c -->
   # Merges each of `other_hashes` into `self`; returns `self`.
@@ -1401,8 +1429,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 = h.merge! { |key, old_value, new_value| raise 'Cannot happen' }
   #     h1 # => {:foo=>0, :bar=>1, :baz=>2}
   #
-  def merge!: (*::Hash[K, V] other_hashes) -> self
-            | (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> V } -> self
+  def merge!: (*hash[K, V] other_hashes) -> self
+            | (*hash[K, V] other_hashes) { (K key, V oldval, V newval) -> V } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1416,7 +1444,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Returns `nil` if no such value found.
   #
-  def rassoc: (V) -> [ K, V ]?
+  def rassoc: (_Equals value) -> [ K, V ]?
 
   # <!--
   #   rdoc-file=hash.c
@@ -1431,6 +1459,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   def rehash: () -> self
 
+  def freeze: () -> self
+
   # <!--
   #   rdoc-file=hash.c
   #   - hash.reject {|key, value| ... } -> new_hash
@@ -1448,8 +1478,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 = e.each {|key, value| key.start_with?('b') }
   #     h1 # => {:foo=>0}
   #
-  def reject: () -> ::Enumerator[[ K, V ], ::Hash[K, V]]
-            | () { (K, V) -> boolish } -> ::Hash[K, V]
+  def reject: () -> Enumerator[[ K, V ], Hash[K, V]]
+            | () { (K key, V value) -> boolish } -> Hash[K, V]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1468,8 +1498,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.reject! # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:reject!>
   #     e.each {|key, value| key.start_with?('b') } # => {:foo=>0}
   #
-  def reject!: () -> ::Enumerator[[ K, V ], self?]
-             | () { (K, V) -> boolish } -> self?
+  def reject!: () -> Enumerator[[ K, V ], self?]
+             | () { (K key, V value) -> boolish } -> self?
 
   # <!-- rdoc-file=hash.c -->
   # Replaces the entire contents of `self` with the contents of `other_hash`;
@@ -1477,13 +1507,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.replace({bat: 3, bam: 4}) # => {:bat=>3, :bam=>4}
   #
-  def replace: (Hash[K, V]) -> self
+  def replace: (hash[K, V] other) -> self
 
-  # <!--
-  #   rdoc-file=hash.c
-  #   - hash.select {|key, value| ... } -> new_hash
-  #   - hash.select -> new_enumerator
-  # -->
+  # <!-- rdoc-file=hash.c -->
   # Returns a new `Hash` object whose entries are those for which the block
   # returns a truthy value:
   #     h = {foo: 0, bar: 1, baz: 2}
@@ -1494,13 +1520,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.select # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select>
   #     e.each {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
   #
-  alias select filter
+  alias filter select
 
-  # <!--
-  #   rdoc-file=hash.c
-  #   - hash.select! {|key, value| ... } -> self or nil
-  #   - hash.select! -> new_enumerator
-  # -->
+  # <!-- rdoc-file=hash.c -->
   # Returns `self`, whose entries are those for which the block returns a truthy
   # value:
   #     h = {foo: 0, bar: 1, baz: 2}
@@ -1513,7 +1535,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     e = h.select!  # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select!>
   #     e.each { |key, value| value < 2 } # => {:foo=>0, :bar=>1}
   #
-  alias select! filter!
+  alias filter! select!
 
   # <!--
   #   rdoc-file=hash.c
@@ -1529,16 +1551,12 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   def shift: () -> [ K, V ]?
 
-  # <!--
-  #   rdoc-file=hash.c
-  #   - hash.length -> integer
-  #   - hash.size -> integer
-  # -->
+  # <!-- rdoc-file=hash.c -->
   # Returns the count of entries in `self`:
   #
   #     {foo: 0, bar: 1, baz: 2}.length # => 3
   #
-  alias size length
+  alias length size
 
   # <!--
   #   rdoc-file=hash.c
@@ -1550,7 +1568,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Any given `keys` that are not found are ignored.
   #
-  def slice: (*K) -> ::Hash[K, V]
+  def slice: [K2 < _Key] (*K2 keys) -> Hash[K2, V]
 
   # <!-- rdoc-file=hash.c -->
   # Associates the given `value` with the given `key`; returns `value`.
@@ -1580,7 +1598,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.to_a # => [[:foo, 0], [:bar, 1], [:baz, 2]]
   #
-  def to_a: () -> ::Array[[ K, V ]]
+  def to_a: () -> Array[[ K, V ]]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1600,7 +1618,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 # => {0=>:foo, 1=>:bar, 2=>:baz}
   #
   def to_h: () -> Hash[K, V]
-          | [A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B]
+          | [A, B] () { (K key, V value) -> _Pair[A, B] } -> Hash[A, B]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1670,7 +1688,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 # => {"foo"=>0, "bar"=>1, "baz"=>2}
   #
   def transform_keys: () -> Enumerator[K, Hash[untyped, V]]
-                    | [A] () { (K) -> A } -> Hash[A, V]
+                    | [K2] (hash[_Key, K2] replacements) -> Hash[K | K2, V]
+                    | [K2] (hash[_Key, K2] replacements) { (K old_key) -> K2 } -> Hash[K2, V]
+                    | [K2] () { (K key) -> K2 } -> Hash[K2, V]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1683,7 +1703,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # returning a new hash.
   #
   def transform_keys!: () -> Enumerator[K, self]
-                     | () { (K) -> K } -> self
+                     | (hash[K, K] replacements) ?{ (K key) -> K } -> self
+                     | () { (K key) -> K } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1706,7 +1727,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 # => {:foo=>0, :bar=>100, :baz=>200}
   #
   def transform_values: () -> Enumerator[V, Hash[K, untyped]]
-                      | [A] () { (V) -> A } -> Hash[K, A]
+                      | [V2] () { (V value) -> V2 } -> Hash[K, V2]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1725,7 +1746,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h1 # => {:foo=>0, :bar=>100, :baz=>200}
   #
   def transform_values!: () -> Enumerator[V, self]
-                       | () { (V) -> V } -> self
+                       | () { (V value) -> V } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1789,7 +1810,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.values # => [0, 1, 2]
   #
-  def values: () -> ::Array[V]
+  def values: () -> Array[V]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1803,7 +1824,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   # that are not found:
   #     h.values_at(:hello, :foo) # => [nil, 0]
   #
-  def values_at: (*K arg0) -> ::Array[V?]
+  def values_at: (*_Key keys) -> Array[V?]
 
   private
 
@@ -1844,9 +1865,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # allocated with enough capacity to accommodate this many keys without having to
   # be resized.
   #
-  def initialize: (?capacity: int) -> void
-                | (V default, ?capacity: int) -> void
-                | (?capacity: int) { (Hash[K, V] hash, K key) -> V } -> void
+  def initialize: (?V default_value, ?capacity: int) -> void
+                | (?capacity: int) { (instance hash, _Key key) -> V } -> void
 
   # <!--
   #   rdoc-file=hash.c
@@ -1857,5 +1877,5 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.replace({bat: 3, bam: 4}) # => {:bat=>3, :bam=>4}
   #
-  def initialize_copy: (self object) -> self
+  alias initialize_copy replace
 end
diff --git a/lib/rbs/test/type_check.rb b/lib/rbs/test/type_check.rb
index 980d5dd2d..40e6288ee 100644
--- a/lib/rbs/test/type_check.rb
+++ b/lib/rbs/test/type_check.rb
@@ -340,7 +340,12 @@ def value(val, type)
         when Types::Variable
           true
         when Types::Literal
-          type.literal == val
+          begin
+            type.literal == val
+          rescue NoMethodError
+            raise if defined?(val.==)
+            false
+          end
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection
diff --git a/test/stdlib/Hash_test.rb b/test/stdlib/Hash_test.rb
index 5f046de2c..14e1ed8b7 100644
--- a/test/stdlib/Hash_test.rb
+++ b/test/stdlib/Hash_test.rb
@@ -1,438 +1,718 @@
 require_relative "test_helper"
 
-class HashTest < StdlibTest
-  target Hash
+class HashSingletonTest < Test::Unit::TestCase
+  include TestHelper
 
-  # Hash[]
-  def test_singleton_aref
-    Hash[a: 42, b: 43]
-    Hash[[[:a, 1], [:b, 3]]]
-    Hash[:a, 1, :b, 3]
-  end
+  testing 'singleton(Hash)'
+
+  Subclass = Class.new(Hash)
+
+  def test_op_aref
+    with_hash 'hello' => :word do |hash|
+      assert_send_type '(hash[String, Symbol]) -> HashSingletonTest::Subclass[String, Symbol]',
+                       Subclass, :[], hash
+    end
 
-  def test_singleton_try_convert
-    Hash.try_convert({foo: 1})
-    Hash.try_convert(nil)
-    Hash.try_convert(42)
+    with_array :a, 1 do |pair1|
+      with_array :b, 2 do |pair2|
+        with_array pair1, pair2 do |ary|
+          assert_send_type '(array[Hash::_Pair[String, Symbol]]) -> HashSingletonTest::Subclass[Symbol, Integer]',
+                           Subclass, :[], ary
+        end
+      end
+    end
+
+    assert_send_type '(*String | Integer) -> Hash[String | Integer, String | Integer]',
+                     Subclass, :[], 'a', 1, 'b', 2
   end
 
-  # test_<
-  def test_less_than
-    _ = { a: 1 } < { a: 1, b: 2 }
-    _ = { a: 1 } < { 'a' => '1' }
+  def test_try_convert
+    with_hash 'hello' => :word do |hash|
+      assert_send_type '(hash[String, Symbol]) -> Hash[String, Symbol]',
+                       Hash, :try_convert, hash
+    end
+
+    with_untyped do |untyped|
+      next if defined? untyped.to_hash
+
+      assert_send_type '(untyped) -> nil',
+                       Hash, :try_convert, untyped
+    end
   end
 
-  # test_<=
-  def test_less_than_equal
-    _ = { a: 1 } <= { a: 1, b: 2 }
-    _ = { a: 1 } <= { 'a' => '1' }
+  def test_new
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     Hash, :new
+    assert_send_type '(Rational) -> Hash[Symbol, Rational]',
+                     Hash, :new, 1r
+    assert_send_type '() { (Hash[Symbol, Rational], Hash::_Key) -> Rational } -> Hash[Symbol, Rational]',
+                     Hash, :new do 1r end
+
+    with_int 1 do |capacity|
+      assert_send_type '(capacity: int) -> Hash[Symbol, Rational]',
+                       Hash, :new, capacity: capacity
+      assert_send_type '(Rational, capacity: int) -> Hash[Symbol, Rational]',
+                       Hash, :new, 1r, capacity: capacity
+      assert_send_type '(capacity: int) { (Hash[Symbol, Rational], Hash::_Key) -> Rational } -> Hash[Symbol, Rational]',
+                       Hash, :new, capacity: capacity do 1r end
+    end
   end
+end
+
+class HashInstanceTest < Test::Unit::TestCase
+  include TestHelper
+
+  testing 'Hash[Symbol, Rational]'
 
-  def test_eqeq
-    _ = { a: 1 } == { a: 1 }
-    _ = { a: 1 } == { b: 2 }
+  class BlankKey < BlankSlate
+    def initialize(key) = @key = key
+    def hash = @key.hash
+    def eql?(rhs) = @key.eql?(rhs)
   end
 
-  # test_>
-  def test_greater_than
-    _ = { a: 1 } > { a: 1, b: 2 }
-    _ = { a: 1 } > { a: 1, b: '2' }
+  def with_key(key)
+    yield key
+    yield BlankKey.new key
   end
 
-  # test_>=
-  def test_greater_than_equal
-    _ = { a: 1 } >= { a: 1, b: 2 }
-    _ = { a: 1 } >= { ab: 1, b: 2 }
+  def test_op_lt
+    with_hash a: 3, 'b' => 4 do |hash|
+      assert_send_type '(hash[untyped, untyped]) -> bool',
+                       {a: 1r}, :<, hash
+    end
   end
 
-  def test_aref
-    { foo: 1 }[:foo]
-    { foo: 1 }[1]
+  def test_op_le
+    with_hash a: 3, 'b' => 4 do |hash|
+      assert_send_type '(hash[untyped, untyped]) -> bool',
+                       {a: 1r}, :<=, hash
+    end
   end
 
-  def test_aset
-    hash = { foo: 1 }
-    hash[:a] = 2
-    hash.store(:b, 3)
+  def test_op_gt
+    with_hash a: 3, 'b' => 4 do |hash|
+      assert_send_type '(hash[untyped, untyped]) -> bool',
+                       {a: 1r}, :>, hash
+    end
   end
 
-  def test_any?
-    { foo: 1, bar: 2 }.any?
-    { foo: 1, bar: 2 }.any?(Array)
-    # Pending because I tried to pass the test but I can't
-    # { foo: 1, bar: 2 }.any? { |k, v| k == :foo && v == 1 }
+  def test_op_ge
+    with_hash a: 3, 'b' => 4 do |hash|
+      assert_send_type '(hash[untyped, untyped]) -> bool',
+                       {a: 1r}, :>=, hash
+    end
   end
 
-  def test_assoc
-    { foo: 1, bar: 2 }.assoc(:foo)
-    { foo: 1, bar: 2 }.assoc(:baz)
+  def test_rehash
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :rehash
   end
 
-  def test_clear
-    { foo: 1, bar: 2 }.clear
+  def test_freeze
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :freeze
   end
 
-  def test_compact
-    { a: nil }.compact
-    { a: nil, b: 2 }.compact
-    { b: 2 }.compact
-    Class.new(Hash)[:a, nil].compact
+  def test_to_hash
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :to_hash
   end
 
-  def test_compact!
-    { a: nil }.compact!
-    { a: 1 }.compact!
+  def test_to_a
+    assert_send_type '() -> Array[[Symbol, Rational]]',
+                     {a: 1r}, :to_a
   end
 
-  def test_compare_by_identity
-    { a: 1 }.compare_by_identity
+  def test_to_h
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :to_h
+
+    with_array 'a', 1i do |pair|
+      assert_send_type '[A, B] () { (Symbol, Rational) -> Hash::_Pair[A, B] } -> Hash[A, B]',
+                       {a: 1r}, :to_h do pair end
+    end
   end
 
-  def test_compare_by_identity?
-    hash = { a: 1 }
-    hash.compare_by_identity?
-    hash.compare_by_identity
-    hash.compare_by_identity?
+  def test_inspect(method: :inspect)
+    assert_send_type '() -> String',
+                     {a: 1r}, method
   end
 
-  def test_deconstruct_keys
-    { a: 1 }.deconstruct_keys([])
-    { a: 1 }.deconstruct_keys([:a])
-    { a: 1 }.deconstruct_keys(nil)
+  def test_to_s
+    test_inspect(method: :to_s)
   end
 
-  # default and default=
-  def test_default
-    hash = {}
-    hash.default
-    hash.default = 1
-    hash.default
+  def test_to_proc
+    assert_send_type '() -> ^(Symbol) -> Rational?',
+                     {a: 1r}, :to_proc
+
+    # Make sure return type is correct
+    assert_type 'Rational', {a: 1r}.to_proc.call(:a)
+    assert_type 'nil', {a: 1r}.to_proc.call(:not_a_key)
+
+    # make sure it only takes one argument
+    assert_raises ArgumentError do {a: 1r}.to_proc.call(:a, :b) end
+    assert_raises ArgumentError do {a: 1r}.to_proc.call() end
   end
 
-  # default_proc and default_proc=
-  def test_default_proc
-    hash = {}
-    hash.default_proc
-    hash.default_proc = proc { |h, k| k }
-    hash.default_proc
-    hash.default_proc = nil
-    hash.default_proc
-    hash.default_proc = :key
-    hash.default_proc
+  def test_op_eq
+    h = {a: 1r}
+    with_untyped.and h do |untyped|
+      assert_send_type '(untyped) -> bool',
+                       h, :==, untyped
+    end
   end
 
-  def test_delete
-    hash = { a: 123 }
-    hash.delete(:a)
-    hash.delete(:z)
-    hash.delete(:z) { |k| "#{k} not found" }
+  def test_op_aref
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key) -> Rational',
+                       {a: 1r}, :[], key
+    end
+
+    with_key :not_a_key do |key|
+      assert_send_type '(Hash::_Key) -> nil',
+                       {a: 1r}, :[], key
+    end
   end
 
-  def test_delete_if
-    hash = { a: 123 }
-    hash.delete_if
-    hash.delete_if { |k, v| k == :a && v == 123 }
+  def test_hash
+    assert_send_type '() -> Integer',
+                     {a: 1r}, :hash
   end
 
-  def test_dig
-    hash = { a: 123, b: { foo: 1 } }
-    hash.dig(:a)
-    hash.dig(:b, :foo)
+  def test_eql?
+    h = {a: 1r}
+    with_untyped.and h do |untyped|
+      assert_send_type '(untyped) -> bool',
+                       h, :eql?, untyped
+    end
   end
 
-  def test_each
-    h = { a: 123 }
+  def test_fetch
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key) -> Rational',
+                       {a: 1r}, :fetch, key
+
+      with_untyped do |default_value|
+        assert_send_type '(Hash::_Key, untyped) -> Rational',
+                         {a: 1r}, :fetch, key, default_value
+      end
 
-    h.each do |k, v|
-      # nop
+      assert_send_type '[K2 < Hash::_Key] (K2) {(K2) -> void} -> Rational',
+                       {a: 1r}, :fetch, key do fail end
     end
 
-    h.each do |x|
-      # nop
-    end
+    with_key :not_a_key do |key|
+      with_untyped do |default_value|
+        assert_send_type '[T] (Hash::_Key, T) -> T',
+                         {a: 1r}, :fetch, key, default_value
 
-    h.each.each do |x, y|
-      #
+        assert_send_type '[K2 < Hash::_Key, T] (K2) { (K2) -> T } -> T',
+                         {a: 1r}, :fetch, key do default_value end
+      end
     end
   end
 
-  def test_each_key
-    h = { a: 123 }
+  def test_op_aset(method: :[]=)
+    assert_send_type '(Symbol, Rational) -> Rational',
+                     {a: 1r}, method, :a, 10r
+    assert_send_type '(Symbol, Rational) -> Rational',
+                     {a: 1r}, method, :not_a_key, 10r
+  end
 
-    h.each_key do |k|
-      # nop
+  def test_store
+    test_op_aset(method: :store)
+  end
+
+  def test_default
+    no_default = {a: 10r}
+    with_default = Hash.new(10r)
+
+    assert_send_type '() -> nil',
+                     no_default, :default
+    assert_send_type '() -> Rational',
+                     with_default, :default
+
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key) -> nil',
+                       no_default, :default, key
+      assert_send_type '(Hash::_Key) -> Rational',
+                       with_default, :default, key
     end
+  end
 
-    h.each_key
+  def test_default=
+    assert_send_type '(Rational) -> Rational',
+                     {a: 1r}, :default=, 1r
   end
 
-  def test_each_value
-    h = { a: 123 }
+  def test_default_proc
+    assert_send_type '() -> nil',
+                     {a: 1r}, :default_proc
+    assert_send_type '() -> ^(HashInstanceTest::Subclass[Symbol, Rational], Hash::_Key) -> Rational',
+                     Subclass.new{ :oops }, :default_proc
+  end
+
+  Subclass = Class.new(Hash)
+
+  def test_default_proc=
+    assert_send_type '(nil) -> nil',
+                     {}, :default_proc=, nil
+    assert_send_type '(^(HashInstanceTest::Subclass[Symbol, Rational], Hash::_Key) -> Rational) -> ^(HashInstanceTest::Subclass[Symbol, Rational], Hash::_Key) -> Rational',
+                     Subclass[], :default_proc=, ->(h, k) { 1r }
 
-    h.each_value do |v|
-      # nop
+    toproc = BlankSlate.new
+    def toproc.to_proc = ->(h, k) { 1r }
+    with proc{}, toproc do |proc_like|
+      assert_send_type '(_ToProc) -> Proc',
+                       {}, :default_proc=, proc_like
     end
+  end
+
+  def test_key
+    equals_1r = BlankSlate.new
+    def equals_1r.==(r) = 1r == r
 
-    h.each_value
+    assert_send_type '(Hash::_Equals) -> Symbol',
+                     { a: 1r, b: 2r }, :key, equals_1r
+    assert_send_type '(Hash::_Equals) -> nil',
+                     { a: 3r, b: 2r }, :key, equals_1r
+  end
+
+  def test_size(method: :size)
+    assert_send_type '() -> Integer',
+                     {a: 1r}, method
+  end
+
+  def test_length
+    test_size(method: :length)
   end
 
   def test_empty?
-    {}.empty?
-    { a: 1 }.empty?
+    assert_send_type '() -> bool',
+                     {a: 1r}, :empty?
   end
 
-  def test_eql?
-    { a: 1 }.eql?({ a: 1 })
-    { a: 2 }.eql?({ a: 1 })
+  def test_each_value
+    assert_send_type '() -> Enumerator[Rational, Hash[Symbol, Rational]]',
+                     {a: 1r}, :each_value
+    assert_send_type '() { (Rational) -> void } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :each_value do end
   end
 
-  def test_except
-    omit_if(!Hash.method_defined?(:except))
-    { a: 100, b: 200, c: 300 }.except(:a)
-    { a: 100, b: 200, c: 300 }.except(:b, :c, :d)
+  def test_each_key
+    assert_send_type '() -> Enumerator[Symbol, Hash[Symbol, Rational]]',
+                     {a: 1r}, :each_key
+    assert_send_type '() { (Symbol) -> void } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :each_key do end
   end
 
-  def test_fetch
-    hash = { a: 1 }
-    hash.fetch(:a)
-    hash.fetch(:b, 2)
-    hash.fetch(:b) { |key| key }
+  def test_each(method: :each)
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, method
+    assert_send_type '() { ([Symbol, Rational]) -> void } -> Hash[Symbol, Rational]',
+                     {a: 1r}, method do end
   end
 
-  def test_fetch_values
-    hash = { a: 1, b: 42 }
-    hash.fetch_values(:a)
-    hash.fetch_values(:a, :b)
-    hash.fetch_values(:unknown) { |key| key }
+  def test_each_pair
+    test_each(method: :each_pair)
   end
 
-  def test_filter
-    { a: 1, b: 2 }.filter
-    { a: 1, b: 2 }.filter { |k, v| v == 1 }
-    Class.new(Hash)[:a, nil].filter.each { |k, v| k }
-    Class.new(Hash)[:a, nil].filter { |k, v| k }
+  def test_transform_keys
+    assert_send_type '() -> Enumerator[Symbol, Hash[untyped, Rational]]',
+                     {a: 1r}, :transform_keys
+
+    with_hash a: 'hello', 'not_a_symbol' => 'what' do |replacements|
+      assert_send_type '(hash[Hash::_Key, String]) -> Hash[Symbol | String, Rational]',
+                       {a: 1r}, :transform_keys, replacements
+      assert_send_type '(hash[Hash::_Key, String]) { (Symbol) -> String } -> Hash[String, Rational]',
+                       {a: 1r}, :transform_keys, replacements, &:to_s
+    end
 
-    { a: 1, b: 2 }.select
-    { a: 1, b: 2 }.select { |k, v| v == 1 }
-    Class.new(Hash)[:a, nil].select.each { |k, v| k }
-    Class.new(Hash)[:a, nil].select { |k, v| k }
+    assert_send_type '() { (Symbol) -> String } -> Hash[String, Rational]',
+                     {a: 1r}, :transform_keys, &:to_s
   end
 
-  def test_filter!
-    { a: 1 }.filter!
-    { a: 1 }.filter! { |k, v| v == 0 }
-    { a: 1 }.filter! { |k, v| v == 1 }
+  def test_transform_keys!
+    ## You cannot properly test the following, because when `assert_send_type` tries to figure out
+    ## the types, it ends up converting the hash to `{nil => 1r}`.
+    # assert_send_type '() -> Enumerator[Symbol, Hash[Symbol, Rational]]',
+    #                  {a: 1r}, :transform_keys!
+
+    with_hash a: :hello, 'not_a_symbol' => :what do |replacements|
+      assert_send_type '(hash[Hash::_Key, Symbol]) -> Hash[Symbol, Rational]',
+                       {a: 1r}, :transform_keys!, replacements
+      assert_send_type '(hash[Hash::_Key, Symbol]) { (Symbol) -> Symbol } -> Hash[Symbol, Rational]',
+                       {a: 1r}, :transform_keys!, replacements, &:upcase
+    end
 
-    { a: 1 }.select!
-    { a: 1 }.select! { |k, v| v == 0 }
-    { a: 1 }.select! { |k, v| v == 1 }
+    assert_send_type '() { (Symbol) -> Symbol } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :transform_keys!, &:upcase
   end
 
-  def test_flatten
-    h = { a: 1, b: 2, c: [3, 4, 5] }
-    h.flatten
-    h.flatten(1)
-    h.flatten(2)
+  def test_transform_values
+    assert_send_type '() -> Enumerator[Rational, Hash[Symbol, untyped]]',
+                     {a: 1r}, :transform_values
+    assert_send_type '() { (Rational) -> Complex } -> Hash[Symbol, Complex]',
+                     {a: 1r}, :transform_values, &:i
   end
 
-  def test_has_key?
-    h = { a: 1, b: 42 }
-    h.has_key?(:a)
-    h.has_key?(:x)
-    h.include?(:b)
-    h.key?(:c)
-    h.member?(:x)
+  def test_transform_values!
+    ## You cannot properly test the following, because when `assert_send_type` tries to figure out
+    ## the types, it ends up converting the hash to `{a: nil}`.
+    # assert_send_type '() -> Enumerator[Rational, Hash[Symbol, Rational]]',
+    #                  {a: 1r}, :transform_values!
+    assert_send_type '() { (Rational) -> Rational } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :transform_values! do |rat| rat + 1 end
   end
 
-  def test_has_value?
-    h = { a: 1, b: 42 }
-    h.has_value?(42)
-    h.has_value?(2)
-    h.value?(42)
-    h.value?(2)
+  def test_keys
+    assert_send_type '() -> Array[Symbol]',
+                     {a: 1r}, :keys
   end
 
-  def test_hash
-    { a: 1 }.hash
+  def test_values
+    assert_send_type '() -> Array[Rational]',
+                     {a: 1r}, :values
   end
 
-  def test_inspect
-    { a: 1 }.inspect
-    { a: 1 }.to_s
+  def test_values_at
+    assert_send_type '() -> Array[Rational]',
+                     {a: 1r}, :values_at
+
+    with_key :a do |key|
+      assert_send_type '(*Hash::_Key) -> Array[Rational]',
+                       {a: 1r}, :values_at, key
+
+      with_key :not_a_key do |not_a_key|
+        assert_send_type '(*Hash::_Key) -> Array[Rational?]',
+                         {a: 1r}, :values_at, key, not_a_key
+      end
+    end
   end
 
-  def test_invert
-    { a: 1, b: 42 }.invert
+  def test_fetch_values
+    assert_send_type '() -> Array[Rational]',
+                     {a: 1r}, :fetch_values
+
+    with_key :a do |key|
+      assert_send_type '(*Hash::_Key) -> Array[Rational]',
+                       {a: 1r}, :fetch_values, key
+      assert_send_type '[K < Hash::_Key] (*K) { (K) -> Complex } -> Array[Rational]',
+                       {a: 1r}, :fetch_values, key do 1i end
+
+      with_key :not_a_key do |not_a_key|
+        assert_send_type '[K < Hash::_Key] (*K) { (K) -> Complex } -> Array[Rational | Complex]',
+                         {a: 1r}, :fetch_values, key, not_a_key do 1i end
+      end
+    end
   end
 
-  def test_keep_if
-    hash = { a: 1, b: 2 }
-    hash.keep_if
-    hash.keep_if { |k, v| k == :a }
+  def test_shift
+    assert_send_type '() -> nil',
+                     {}, :shift
+    assert_send_type '() -> [Symbol, Rational]',
+                     {a: 1r}, :shift
   end
 
-  def test_key
-    hash = { a: 1 }
-    hash.key(1)
-    hash.key(3)
+  def test_delete
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key) -> nil',
+                       {}, :delete, key
+      assert_send_type '(Hash::_Key) -> Rational',
+                       {a: 1r}, :delete, key
+
+      assert_send_type '[K < Hash::_Key] (K) { (K) -> Complex } -> (Rational | Complex)',
+                       {}, :delete, key do 1i end
+      assert_send_type '[K < Hash::_Key] (K) { (K) -> Complex } -> (Rational | Complex)',
+                       {a: 1r}, :delete, key do 1i end
+    end
   end
 
-  def test_keys
-    { a: 1, b: 2 }.keys
+  def test_delete_if
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, :delete_if
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :delete_if do :boolish end
   end
 
-  def test_length
-    { a: 1, b: 2 }.length
-    { a: 1, b: 2 }.size
+  def test_keep_if
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, :keep_if
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :keep_if do :boolish end
   end
 
-  def test_merge
-    hash = { a: 1, b: 2 }
-    hash.merge({ 'k' => 'v' })
-    hash.merge({ a: 3 }) { |k, v1, v2| [v1, v2] }
+  def test_select(method: :select)
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, method
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, method do :boolish end
   end
 
-  def test_merge!
-    hash = { a: 1, b: 2 }
-    hash.merge!({ 'k' => 'v' })
-    hash.merge!({ a: 3 }) { |k, v1, v2| [v1, v2] }
-    hash.update({ 'foo' => 42 })
+  def test_select!(method: :select!)
+    assert_send_type '() -> Enumerator[[Symbol, Rational], nil]',
+                     {}, method
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, method
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> nil',
+                     {a: 1r}, method do :boolish end
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, method do nil end
   end
 
-  def test_rassoc
-    hash = { a: 1, b: 2 }
-    hash.rassoc(2)
-    hash.rassoc(42)
+  def test_filter
+    test_select(method: :filter)
   end
 
-  def test_rehash
-    { a: 1, b: 2 }.rehash
+  def test_filter!
+    test_select!(method: :filter!)
   end
 
   def test_reject
-    hash = { a: 1, b: 2 }
-    hash.reject
-    hash.reject { |k, v| k == :a }
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]]',
+                     {a: 1r}, :reject
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :reject do :boolish end
   end
 
   def test_reject!
-    hash = { a: 1, b: 2 }
-    hash.reject!
-    hash.reject! { |k, v| k == :a }
-    hash.reject! { |k, v| k == :a }
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]?]',
+                     {}, :reject!
+    assert_send_type '() -> Enumerator[[Symbol, Rational], Hash[Symbol, Rational]?]',
+                     {a: 1r}, :reject!
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> Hash[Symbol, Rational]',
+                     {a: 1r}, :reject! do :boolish end
+    assert_send_type '() { (Symbol, Rational) -> boolish } -> nil',
+                     {a: 1r}, :reject! do nil end
   end
 
-  def test_replace
-    { a: 1 }.replace({ b: 2 })
-    { a: 1 }.replace({ 'b' => 2.0 })
+  def test_slice
+    assert_send_type '[K < Hash::_Key] (*K) -> Hash[K, Rational]',
+                     {a: 1r}, :slice
+    with_key :a do |key|
+      assert_send_type '[K < Hash::_Key] (*K) -> Hash[K, Rational]',
+                       {a: 1r}, :slice, key
+      with_key :not_a_key do |not_a_key|
+        assert_send_type '[K < Hash::_Key] (*K) -> Hash[K, Rational]',
+                         {a: 1r}, :slice, key, not_a_key
+      end
+    end
   end
 
-  def test_shift
-    {}.shift
-    { a: 42 }.shift
+  def test_except
+    assert_send_type '(*Hash::_Key) -> Hash[Symbol, Rational]',
+                     {a: 1r, b: 2r}, :except
+
+    with_key :a do |key|
+      assert_send_type '(*Hash::_Key) -> Hash[Symbol, Rational]',
+                       {a: 1r, b: 2r}, :except, key
+
+      with_key :not_a_key do |not_a_key|
+        assert_send_type '(*Hash::_Key) -> Hash[Symbol, Rational]',
+                         {a: 1r, b: 2r}, :except, key, not_a_key
+      end
+    end
   end
 
-  def test_slice
-    { a: 42, b: 43, c: 44 }.slice(:a)
-    { a: 42, b: 43, c: 44 }.slice(:a, :b)
-    Class.new(Hash)[:a, 42].slice(:a)
+  def test_clear
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r, b: 2r}, :clear
   end
 
-  def test_to_a
-    { a: 42 }.to_a
+  def test_invert
+    assert_send_type '() -> Hash[Rational, Symbol]',
+                     {a: 1r, b: 2r}, :invert
   end
 
-  def test_to_h
-    { a: 42 }.to_h
-    { a: 42 }.to_h { |k, v| [k.to_s, v.to_f] }
+  def test_update
+    test_merge!(method: :update)
   end
 
-  def test_to_hash
-    { a: 42 }.to_hash
-    Class.new(Hash)[:a, 42].to_hash
+  def test_replace(method: :replace)
+    with_hash a: 2r do |hash|
+      assert_send_type '(hash[Symbol, Rational]) -> Hash[Symbol, Rational]',
+                       {a: 1r}, method, hash
+    end
   end
 
-  def test_to_proc
-    { a: 1 }.to_proc.call(:a)
-    { a: 1 }.to_proc.call(:b)
+  def test_initialize_copy
+    test_replace(method: :initialize_copy)
   end
 
-  def test_transform_keys
-    { a: 1, b: 2 }.transform_keys
-    { a: 1, b: 2 }.transform_keys(&:to_s)
+  def test_merge!(method: :merge!)
+    assert_send_type '(*hash[Symbol, Rational]) -> Hash[Symbol, Rational]',
+                     {a: 1r}, method
+    assert_send_type '(*hash[Symbol, Rational]) {(Symbol, Rational, Rational) -> Rational} -> Hash[Symbol, Rational]',
+                     {a: 1r}, method do 2r end
+
+    with_hash b: 2r do |hash1|
+      assert_send_type '(*hash[Symbol, Rational]) -> Hash[Symbol, Rational]',
+                       {a: 1r}, method, hash1
+      assert_send_type '(*hash[Symbol, Rational]) {(Symbol, Rational, Rational) -> Rational} -> Hash[Symbol, Rational]',
+                       {a: 1r}, method, hash1 do 2r end
+
+      with_hash a: 3r do |hash2|
+        assert_send_type '(*hash[Symbol, Rational]) -> Hash[Symbol, Rational]',
+                         {a: 1r}, method, hash1, hash2
+        assert_send_type '(*hash[Symbol, Rational]) {(Symbol, Rational, Rational) -> Rational} -> Hash[Symbol, Rational]',
+                         {a: 1r}, method, hash1, hash2 do 2r end
+      end
+    end
   end
 
-  def test_transform_keys!
-    { a: 1, b: 2 }.transform_keys!
-    { a: 1, b: 2 }.transform_keys!(&:to_s)
+  def test_merge
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :merge
+    assert_send_type '() { (Symbol, Rational, Complex) -> Float} -> Hash[Symbol, Rational]',
+                     {a: 1r}, :merge do 1.0 end
+
+    with_hash 'b' => 2i do |hash1|
+      assert_send_type '(*hash[String, Complex]) -> Hash[Symbol | String, Rational | Complex]',
+                       {a: 1r}, :merge, hash1
+      assert_send_type '(*hash[String, Complex]) { (Symbol, Rational, Complex) -> Float} -> Hash[Symbol | String, Rational | Complex]',
+                       {a: 1r}, :merge, hash1 do 1.0 end
+
+      with_hash a: 3i do |hash2|
+        assert_send_type '(*hash[String, Complex]) -> Hash[Symbol | String, Rational | Complex]',
+                         {a: 1r}, :merge, hash1, hash2
+        assert_send_type '(*hash[String, Complex]) { (Symbol, Rational, Complex) -> Float} -> Hash[Symbol | String, Rational | Complex | Float]',
+                         {a: 1r}, :merge, hash1, hash2 do 1.0 end
+      end
+    end
   end
 
-  def test_transform_values
-    { a: 1, b: 2 }.transform_values
-    { a: 1, b: 2 }.transform_values(&:to_s)
+  def test_assoc
+    equals_symbol_a = BlankSlate.new
+    def equals_symbol_a.==(r) = :a == r
+
+    with :a, equals_symbol_a do |key|
+      assert_send_type '(Hash::_Equals) -> [Symbol, Rational]',
+                       {a: 1r}, :assoc, key
+      assert_send_type '(Hash::_Equals) -> nil',
+                       {b: 1r}, :assoc, key
+    end
   end
 
-  def test_transform_values!
-    { a: 1, b: 2 }.transform_values!
-    { a: 1, b: 2 }.transform_values!(&:to_s)
+  def test_rassoc
+    equals_1r = BlankSlate.new
+    def equals_1r.==(r) = 1r == r
+
+    with 1r, equals_1r do |value|
+      assert_send_type '(Hash::_Equals) -> [Symbol, Rational]',
+                       {a: 1r}, :rassoc, value
+      assert_send_type '(Hash::_Equals) -> nil',
+                       {a: 2r}, :rassoc, value
+    end
   end
 
-  def test_values
-    { a: 1, b: 2 }.values
+  def test_flatten
+    assert_send_type '() -> Array[Symbol | Rational]',
+                     {a: 1r}, :flatten
+    assert_send_type '(1) -> Array[Symbol | Rational]',
+                     {a: 1r}, :flatten, 1
+    assert_send_type '(0) -> Array[[Symbol, Rational]]',
+                     {a: 1r}, :flatten, 0
+
+    with_int -1 do |level|
+      assert_send_type '(int) -> Array[untyped]',
+                       {a: 1r}, :flatten, level
+    end
   end
 
-  def test_values_at
-    { a: 1, b: 2, c: 3 }.values_at(:a, :b, :d)
+  def test_compact
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r, b: nil}, :compact
   end
-end
 
-class HashInstanceTest < Test::Unit::TestCase
-  include TestHelper
+  def test_compact!
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r, b: nil}, :compact!
+    assert_send_type '() -> nil',
+                     {a: 1r, b: 2r}, :compact!
+  end
 
-  testing "::Hash[::Symbol, ::Integer]"
+  def test_include?
+    test_has_key?(method: :include?)
+  end
 
-  def test_except
-    assert_send_type "() -> ::Hash[::Symbol, ::Integer]",
-                      { a: 100, b: 200, c: 300 }, :except
-    assert_send_type "(*Symbol keys) -> ::Hash[::Symbol, ::Integer]",
-                      { a: 100, b: 200, c: 300 }, :except, :a
+  def test_member?
+    test_has_key?(method: :member?)
   end
-end
 
-class HashSingletonTest < Test::Unit::TestCase
-  include TestHelper
+  def test_has_key?(method: :has_key?)
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key) -> bool',
+                       {a: 1r}, method, key
+      assert_send_type '(Hash::_Key) -> bool',
+                       {b: 1r}, method, key
+    end
+  end
 
-  testing "singleton(::Hash)"
+  def test_has_value?(method: :has_value?)
+    equals_1r = BlankSlate.new
+    def equals_1r.==(r) = 1r == r
 
-  def test_new
-    assert_send_type(
-      "() -> ::Hash[untyped, untyped]",
-      Hash, :new
-    )
-    assert_send_type(
-      "(String) -> ::Hash[untyped, String]",
-      Hash, :new, "default"
-    )
-    assert_send_type(
-      "() { (Hash[untyped, untyped], untyped) -> untyped } -> ::Hash[untyped, String]",
-      Hash, :new, &-> (hash, key) { }
-    )
-
-    if_ruby("3.4"..., skip: false) do
-      with_int(1) do |int|
-        assert_send_type(
-          "(capacity: int) -> ::Hash[untyped, untyped]",
-          Hash, :new, capacity: int
-        )
-        assert_send_type(
-          "(String, capacity: int) -> ::Hash[untyped, String]",
-          Hash, :new, "default", capacity: int
-        )
-        assert_send_type(
-          "(capacity: int) { (Hash[untyped, untyped], untyped) -> untyped } -> ::Hash[untyped, String]",
-          Hash, :new, capacity: int, &-> (hash, key) { }
-        )
-      end
+    with 1r, equals_1r do |value|
+      assert_send_type '(Hash::_Equals) -> bool',
+                       {a: 1r}, method, value
+      assert_send_type '(Hash::_Equals) -> bool',
+                       {a: 12}, method, value
+    end
+  end
+
+  def test_key?
+    test_has_key?(method: :key?)
+  end
+
+  def test_value?
+    test_has_value?(method: :value?)
+  end
+
+  def test_compare_by_identity
+    assert_send_type '() -> Hash[Symbol, Rational]',
+                     {a: 1r}, :compare_by_identity
+  end
+
+  def test_compare_by_identity?
+    assert_send_type '() -> bool',
+                     {a: 1r}, :compare_by_identity?
+    assert_send_type '() -> bool',
+                     {a: 1r}.compare_by_identity, :compare_by_identity?
+  end
+
+  def test_any?
+    assert_send_type '() -> bool',
+                     {}, :any?
+    assert_send_type '() -> bool',
+                     {a: 1r}, :any?
+
+    pattern = BlankSlate.new
+    def pattern.===(r) = r == [:a, 1r] ? :boolish : nil
+    assert_send_type '(Enumerable::_Pattern) -> bool',
+                     {a: 1r}, :any?, pattern
+    assert_send_type '(Enumerable::_Pattern) -> bool',
+                     {a: 2r}, :any?, pattern
+
+    assert_send_type '() { ([Symbol, Rational]) -> boolish } -> bool',
+                     {a: 1r}, :any? do :boolish end
+    assert_send_type '() { ([Symbol, Rational]) -> boolish } -> bool',
+                     {a: 1r}, :any? do nil end
+  end
+
+  def test_dig
+    with_key :a do |key|
+      assert_send_type '(Hash::_Key, *untyped) -> untyped',
+                       {a: [1r]}, :dig, key, 0
+      assert_send_type '(Hash::_Key, *untyped) -> untyped',
+                       {b: [1r]}, :dig, key, 0
+    end
+  end
+
+  def test_deconstruct_keys
+    with_untyped do |argument|
+      assert_send_type '(untyped) -> Hash[Symbol, Rational]',
+                       {a: 1r}, :deconstruct_keys, argument
     end
   end
 end