diff --git a/core/enumerable.rbs b/core/enumerable.rbs
index f255f167e..e433f0ca6 100644
--- a/core/enumerable.rbs
+++ b/core/enumerable.rbs
@@ -1299,7 +1299,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # With no block given, returns an Enumerator.
   #
   def reverse_each: () { (Elem arg0) -> untyped } -> void
-                  | () -> ::Enumerator[Elem, void]
+                  | () -> ::Enumerator[Elem]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1760,7 +1760,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     # show pythagorean triples less than 100
   #     p pythagorean_triples.take_while { |*, z| z < 100 }.force
   #
-  def lazy: () -> Enumerator::Lazy[Elem, void]
+  def lazy: () -> Enumerator::Lazy[Elem]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2092,8 +2092,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       pp lines
   #     }
   #
-  def chunk: [U] () { (Elem elt) -> U } -> ::Enumerator[[ U, ::Array[Elem] ], void]
-           | () -> ::Enumerator[Elem, ::Enumerator[[ untyped, ::Array[Elem] ], void]]
+  def chunk: [U] () { (Elem elt) -> U } -> ::Enumerator[[ U, ::Array[Elem] ]]
+           | () -> ::Enumerator[Elem, ::Enumerator[[ untyped, ::Array[Elem] ]]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2142,7 +2142,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Enumerable#slice_when does the same, except splitting when the block returns
   # `true` instead of `false`.
   #
-  def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]
+  def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2204,7 +2204,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Enumerable#chunk_while does the same, except splitting when the block returns
   # `false` instead of `true`.
   #
-  def slice_when: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]
+  def slice_when: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2239,8 +2239,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
   #     #=>["foo\n", "barbaz\n", "\n", "qux\n"]
   #
-  def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                 | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]
+  def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem]]
+                 | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2396,6 +2396,6 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       }
   #     }
   #
-  def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                  | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]
+  def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem]]
+                  | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem]]
 end
diff --git a/core/enumerator.rbs b/core/enumerator.rbs
index ecd6587f2..3dc077472 100644
--- a/core/enumerator.rbs
+++ b/core/enumerator.rbs
@@ -127,7 +127,7 @@
 #     puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
 #     # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
 #
-class Enumerator[unchecked out Elem, out Return] < Object
+class Enumerator[unchecked out Elem, out Return = void] < Object
   include Enumerable[Elem]
 
   # A convenience interface for `each` with optional block
@@ -567,7 +567,7 @@ end
 #     # This returns an array of items like a normal enumerator does.
 #     all_checked = active_items.select(&:checked)
 #
-class Enumerator::Lazy[out Elem, out Return] < Enumerator[Elem, Return]
+class Enumerator::Lazy[out Elem, out Return = void] < Enumerator[Elem, Return]
   # <!-- rdoc-file=enumerator.c -->
   # Expands `lazy` enumerator to an array. See Enumerable#to_a.
   #
diff --git a/core/enumerator/product.rbs b/core/enumerator/product.rbs
index 5f79fb266..b16ece144 100644
--- a/core/enumerator/product.rbs
+++ b/core/enumerator/product.rbs
@@ -1,5 +1,5 @@
 %a{annotate:rdoc:skip}
-class Enumerator[unchecked out Elem, out Return]
+class Enumerator[unchecked out Elem, out Return = void]
   # <!-- rdoc-file=enumerator.c -->
   # Enumerator::Product generates a Cartesian product of any number of enumerable
   # objects.  Iterating over the product of enumerable objects is roughly
diff --git a/core/integer.rbs b/core/integer.rbs
index 5922c979a..14afedf6f 100644
--- a/core/integer.rbs
+++ b/core/integer.rbs
@@ -1168,10 +1168,10 @@ class Integer < Numeric
           | (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]
+          | (Numeric limit, ?Integer step) -> Enumerator[Integer]
+          | (Numeric limit, ?Numeric step) -> Enumerator[Numeric]
+          | (to: Numeric, ?by: Integer) -> Enumerator[Integer]
+          | (by: Numeric, ?to: Numeric) -> Enumerator[Numeric]
 
   # <!--
   #   rdoc-file=numeric.c
diff --git a/core/thread.rbs b/core/thread.rbs
index 21e401fc5..26ca97d62 100644
--- a/core/thread.rbs
+++ b/core/thread.rbs
@@ -1545,7 +1545,7 @@ end
 #
 #     consumer.join
 #
-class Thread::Queue < Object
+class Thread::Queue[Elem = untyped] < Object
   # <!-- rdoc-file=thread_sync.c -->
   # Pushes the given `object` to the queue.
   #
@@ -1661,7 +1661,7 @@ class Thread::Queue < Object
   # If `timeout` seconds have passed and no data is available `nil` is returned.
   # If `timeout` is `0` it returns immediately.
   #
-  def pop: (?boolish non_block, ?timeout: _ToF?) -> untyped
+  def pop: (?boolish non_block, ?timeout: _ToF?) -> Elem?
 
   # <!--
   #   rdoc-file=thread_sync.c
@@ -1671,7 +1671,7 @@ class Thread::Queue < Object
   # -->
   # Pushes the given `object` to the queue.
   #
-  def push: (untyped obj) -> void
+  def push: (Elem obj) -> void
 
   # <!--
   #   rdoc-file=thread_sync.rb
@@ -1692,7 +1692,7 @@ end
 #
 # See Thread::Queue for an example of how a Thread::SizedQueue works.
 #
-class Thread::SizedQueue < Thread::Queue
+class Thread::SizedQueue[Elem = untyped] < Thread::Queue[Elem]
   # <!--
   #   rdoc-file=thread_sync.rb
   #   - <<(object, non_block = false, timeout: nil)
@@ -1755,7 +1755,8 @@ class Thread::SizedQueue < Thread::Queue
   # If `timeout` seconds have passed and no space is available `nil` is returned.
   # If `timeout` is `0` it returns immediately. Otherwise it returns `self`.
   #
-  def push: (untyped obj, ?boolish non_block, timeout: _ToF?) -> void
+  def push: (Elem obj, ?boolish non_block) -> void
+          | (Elem obj, timeout: _ToF?) -> self?
 end
 
 class ConditionVariable = Thread::ConditionVariable
diff --git a/lib/rbs/cli/validate.rb b/lib/rbs/cli/validate.rb
index fd2a0de62..bdd3c4cd9 100644
--- a/lib/rbs/cli/validate.rb
+++ b/lib/rbs/cli/validate.rb
@@ -164,7 +164,7 @@ def validate_class_module_definition
             end
 
             if dt = param.default_type
-              void_type_context_validator(dt)
+              void_type_context_validator(dt, true)
               no_self_type_validator(dt)
               no_classish_type_validator(dt)
               @validator.validate_type(dt, context: nil)
@@ -232,6 +232,22 @@ def validate_interface
             location: decl.decl.location&.aref(:type_params)
           )
 
+          decl.decl.type_params.each do |param|
+            if ub = param.upper_bound_type
+              void_type_context_validator(ub)
+              no_self_type_validator(ub)
+              no_classish_type_validator(ub)
+              @validator.validate_type(ub, context: nil)
+            end
+
+            if dt = param.default_type
+              void_type_context_validator(dt, true)
+              no_self_type_validator(dt)
+              no_classish_type_validator(dt)
+              @validator.validate_type(dt, context: nil)
+            end
+          end
+
           decl.decl.members.each do |member|
             case member
             when AST::Members::MethodDefinition
@@ -278,7 +294,31 @@ def validate_type_alias
           @builder.expand_alias1(name).tap do |type|
             @validator.validate_type type, context: nil
           end
+
           @validator.validate_type_alias(entry: decl)
+
+          @validator.validate_type_params(
+            decl.decl.type_params,
+            type_name: name,
+            location: decl.decl.location&.aref(:type_params)
+          )
+
+          decl.decl.type_params.each do |param|
+            if ub = param.upper_bound_type
+              void_type_context_validator(ub)
+              no_self_type_validator(ub)
+              no_classish_type_validator(ub)
+              @validator.validate_type(ub, context: nil)
+            end
+
+            if dt = param.default_type
+              void_type_context_validator(dt, true)
+              no_self_type_validator(dt)
+              no_classish_type_validator(dt)
+              @validator.validate_type(dt, context: nil)
+            end
+          end
+
           no_self_type_validator(decl.decl.type)
           no_classish_type_validator(decl.decl.type)
           void_type_context_validator(decl.decl.type)
diff --git a/lib/rbs/test/type_check.rb b/lib/rbs/test/type_check.rb
index 70fe06286..a24fd290e 100644
--- a/lib/rbs/test/type_check.rb
+++ b/lib/rbs/test/type_check.rb
@@ -260,6 +260,13 @@ def value(val, type)
           Test.call(val, IS_AP, instance_class)
         when Types::ClassInstance
           klass = get_class(type.name) or return false
+          if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
+            args = AST::TypeParam.normalize_args(params, type.args)
+            unless args == type.args
+              type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
+            end
+          end
+
           case
           when klass == ::Array
             Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
diff --git a/test/stdlib/ThreadQueue_test.rb b/test/stdlib/ThreadQueue_test.rb
index c8769bc83..38dd67ede 100644
--- a/test/stdlib/ThreadQueue_test.rb
+++ b/test/stdlib/ThreadQueue_test.rb
@@ -1,86 +1,197 @@
+# frozen_string_literal: true
+
 require_relative "test_helper"
+require "thread"
 
-class ThreadQueueTest < StdlibTest
-  target Thread::Queue
+class Thread__Queue__InstanceTest < Test::Unit::TestCase
+  include TestHelper
 
-  def test_lshift
-    q = Thread::Queue.new
-    q << :a
-  end
+  testing "::Thread::Queue[::Integer]"
 
-  def test_clear
-    q = Thread::Queue.new
-    q.clear
-  end
+  def test_push
+    queue = Thread::Queue.new
 
-  def test_close
-    q = Thread::Queue.new
-    q.close
+    assert_send_type(
+      "(::Integer) -> void",
+      queue, :push, 1
+    )
   end
 
-  def test_closed?
-    q = Thread::Queue.new
-    q.closed?
-    q.close
-    q.closed?
+  def test_length
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :length
+    )
   end
 
-  def test_deq
-    q = Thread::Queue.new
-    3.times { q << :a }
+  def test_num_waiting
+    queue = Thread::Queue.new
 
-    q.deq
-    q.deq(true)
-    q.deq(false)
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :num_waiting
+    )
   end
 
   def test_empty?
-    q = Thread::Queue.new
-    q.empty?
-    q << :a
-    q.empty?
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> bool",
+      queue, :empty?
+    )
   end
 
-  def test_enq
-    q = Thread::Queue.new
-    q.enq(:a)
+  def test_closed?
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> bool",
+      queue, :closed?
+    )
   end
 
-  def test_length
-    q = Thread::Queue.new
-    q.length
+  def test_close
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> void",
+      queue, :close
+    )
   end
 
-  def test_num_waiting
-    q = Thread::Queue.new
-    q.num_waiting
+  def test_clear
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> void",
+      queue, :clear
+    )
   end
 
   def test_pop
-    q = Thread::Queue.new
-    3.times { q << :a }
-    q.pop
-    q.pop(true)
-    q.pop(false)
-    q.pop(timeout: 0.2)
-    q.pop(timeout: ToF.new(0.1).__with_object_methods(:==))
+    queue = Thread::Queue.new
+
+    queue.push(1)
+
+    # Get an Integer from the queue
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :pop
+    )
+
+    queue.push(2)
+
+    # Get an Integer from the queue with timeout
+    assert_send_type(
+      "(timeout: ::Float) -> ::Integer",
+      queue, :pop, timeout: 0.1
+    )
+
+    queue.push(3)
+
+    # Get an Integer from the queue with `nil` timeout
+    assert_send_type(
+      "(timeout: nil) -> ::Integer",
+      queue, :pop, timeout: nil
+    )
+
+    # Returns `nil` when the queue is empty and with timeout
+    assert_send_type(
+      "(timeout: ::Float) -> nil",
+      queue, :pop, timeout: 0.0
+    )
+
+    queue.push(4)
+
+    # With nonblocking is true, but queue is not empty
+    assert_send_type(
+      "(bool) -> ::Integer",
+      queue, :pop, true
+    )
+
+    # Raises an exception with nonblocking but queue is empty
+    begin
+      assert_send_type(
+        "(bool) -> bot",
+        queue, :pop, true
+      )
+    rescue ThreadError
+    end
+
+    queue.close()
+
+    # Returns `nil` if the queue is closed
+    assert_send_type(
+      "() -> nil",
+      queue, :pop
+    )
   end
+end
 
-  def test_push
-    q = Thread::Queue.new
-    q.push(:a)
+
+class Thread__SizedQueue__InstanceTest < Test::Unit::TestCase
+  include TestHelper
+
+  testing "::Thread::SizedQueue[::Integer]"
+
+  def test_max
+    queue = Thread::SizedQueue.new(10)
+
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :max
+    )
   end
 
-  def test_shift
-    q = Thread::Queue.new
-    3.times { q << :a }
-    q.shift
-    q.shift(true)
-    q.shift(false)
+  def test_max=
+    queue = Thread::SizedQueue.new(10)
+
+    assert_send_type(
+      "(::Integer) -> ::Integer",
+      queue, :max=, 20
+    )
   end
 
-  def test_size
-    q = Thread::Queue.new
-    q.size
+  def test_push
+    queue = Thread::SizedQueue.new(1)
+
+    assert_send_type(
+      "(::Integer) -> void",
+      queue, :push, 1
+    )
+
+    queue.pop
+
+    # Nonblocking mode: queue is not full
+    assert_send_type(
+      "(::Integer, bool) -> void",
+      queue, :push, 2, true
+    )
+
+    # Nonblocking mode: queue is full
+    begin
+      assert_send_type(
+        "(::Integer, bool) -> bot",
+        queue, :push, 3, true
+      )
+    rescue ThreadError
+    end
+
+    queue.pop
+
+    # With timeout: queue is not full
+    assert_send_type(
+      "(::Integer, timeout: Float) -> ::Thread::SizedQueue[::Integer]",
+      queue, :push, 3, timeout: 0.3
+    )
+
+    # With timeout: queue is full
+    assert_send_type(
+      "(::Integer, timeout: Float) -> nil",
+      queue, :push, 4, timeout: 0.0
+    )
   end
 end