diff --git a/core/match_data.rbs b/core/match_data.rbs
index 494f2c338b..1d0a633701 100644
--- a/core/match_data.rbs
+++ b/core/match_data.rbs
@@ -45,7 +45,9 @@
 # See also "Special global variables" section in Regexp documentation.
 #
 class MatchData
-  public
+  type capture = String | Symbol | int
+
+  def initialize_copy: (MatchData instance) -> self
 
   # <!-- rdoc-file=re.c -->
   # Returns `true` if `object` is another MatchData object whose target string,
@@ -53,7 +55,8 @@ class MatchData
   #
   # MatchData#eql? is an alias for MatchData#==.
   #
-  def ==: (untyped other) -> bool
+  def ==: (MatchData other) -> bool
+        | (untyped) -> false
 
   # <!--
   #   rdoc-file=re.c
@@ -80,10 +83,9 @@ class MatchData
   #     m['foo'] # => "h"
   #     m[:bar]  # => "ge"
   #
-  def []: (Integer idx) -> String?
-        | (Integer start, Integer length) -> ::Array[String?]
-        | (::Range[Integer] range) -> ::Array[String?]
-        | (interned name) -> String?
+  def []: (capture backref, ?nil) -> String?
+        | (int start, int length) -> Array[String?]
+        | (range[int?] range) -> Array[String?]
 
   # <!--
   #   rdoc-file=re.c
@@ -121,7 +123,7 @@ class MatchData
   #
   # Related: MatchData#end, MatchData#offset, MatchData#byteoffset.
   #
-  def begin: (Integer | interned n_or_name) -> Integer?
+  def begin: (capture backref) -> Integer?
 
   # <!--
   #   rdoc-file=re.c
@@ -139,7 +141,7 @@ class MatchData
   #     p m.byteoffset(:foo) #=> [0, 1]
   #     p m.byteoffset(:bar) #=> [2, 3]
   #
-  def byteoffset: (Integer | interned n_or_name) -> ([ Integer, Integer ] | [ nil, nil ])
+  def byteoffset: (capture backref) -> ([Integer, Integer] | [nil, nil])
 
   # <!--
   #   rdoc-file=re.c
@@ -154,7 +156,7 @@ class MatchData
   #
   # Related: MatchData.to_a.
   #
-  def captures: () -> ::Array[String?]
+  def captures: () -> Array[String?]
 
   # <!-- rdoc-file=re.c -->
   # Returns the array of captures, which are all matches except `m[0]`:
@@ -183,7 +185,7 @@ class MatchData
   #     m = /(\d{2}):(\d{2}):(\d{2})/.match("18:37:22")
   #     m.deconstruct_keys(nil) # => {}
   #
-  def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, String?]
+  def deconstruct_keys: (Array[Symbol]? array_of_names) -> Hash[Symbol, String?]
 
   # <!--
   #   rdoc-file=re.c
@@ -221,7 +223,7 @@ class MatchData
   #
   # Related: MatchData#begin, MatchData#offset, MatchData#byteoffset.
   #
-  def end: (Integer | interned n_or_name) -> Integer?
+  def end: (capture backref) -> Integer?
 
   # <!--
   #   rdoc-file=re.c
@@ -232,7 +234,7 @@ class MatchData
   #
   # MatchData#eql? is an alias for MatchData#==.
   #
-  def eql?: (untyped other) -> bool
+  alias eql? ==
 
   # <!--
   #   rdoc-file=re.c
@@ -276,7 +278,7 @@ class MatchData
   #
   # MatchData#length is an alias for MatchData.size.
   #
-  def length: () -> Integer
+  alias length size
 
   # <!--
   #   rdoc-file=re.c
@@ -301,7 +303,7 @@ class MatchData
   #     # => #<MatchData "01" a:"0" a:"1">
   #     m.named_captures #=> {"a" => "1"}
   #
-  def named_captures: () -> ::Hash[String, String?]
+  def named_captures: () -> Hash[String, String?]
 
   # <!--
   #   rdoc-file=re.c
@@ -322,7 +324,7 @@ class MatchData
   #     m = /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge")
   #     m.regexp.names # => ["foo", "bar", "baz"]
   #
-  def names: () -> ::Array[String]
+  def names: () -> Array[String]
 
   # <!--
   #   rdoc-file=re.c
@@ -348,7 +350,7 @@ class MatchData
   #     m.match('foo') # => "h"
   #     m.match(:bar)  # => "ge"
   #
-  def match: (int | interned) -> String?
+  def match: (capture backref) -> String?
 
   # <!--
   #   rdoc-file=re.c
@@ -375,7 +377,7 @@ class MatchData
   #     m.match_length('foo') # => 1
   #     m.match_length(:bar)  # => 2
   #
-  def match_length: (int | interned) -> Integer?
+  def match_length: (capture backref) -> Integer?
 
   # <!--
   #   rdoc-file=re.c
@@ -414,7 +416,7 @@ class MatchData
   #
   # Related: MatchData#byteoffset, MatchData#begin, MatchData#end.
   #
-  def offset: (Integer | interned n_or_name) -> ([ Integer, Integer ] | [ nil, nil ])
+  def offset: (capture backref) -> ([Integer, Integer] | [nil, nil])
 
   # <!--
   #   rdoc-file=re.c
@@ -500,7 +502,7 @@ class MatchData
   #
   # Related: MatchData#captures.
   #
-  def to_a: () -> ::Array[String?]
+  def to_a: () -> Array[String?]
 
   # <!--
   #   rdoc-file=re.c
@@ -544,9 +546,5 @@ class MatchData
   #     m.values_at(0, 1..2, :a, :b, :op)
   #     # => ["1 + 2", "1", "+", "1", "2", "+"]
   #
-  def values_at: (*Integer | interned n_or_name) -> ::Array[String?]
-
-  private
-
-  def initialize_copy: (self object) -> void
+  def values_at: (*capture | range[int?] backrefs) -> Array[String?]
 end
diff --git a/test/stdlib/MatchData_test.rb b/test/stdlib/MatchData_test.rb
index 794fff9319..6d11265f35 100644
--- a/test/stdlib/MatchData_test.rb
+++ b/test/stdlib/MatchData_test.rb
@@ -1,146 +1,247 @@
-require_relative "test_helper"
+require_relative 'test_helper'
 
-class MatchDataTest < StdlibTest
-  target MatchData
+class MatchDataInstanceTest < Test::Unit::TestCase
+  include TypeAssertions
 
-  # test_==
-  def test_equal
-    foo = 'foo'
-    foo.match('f') == foo.match('f')
+  testing '::MatchData'
+
+  INSTANCE = /[^q](?<a>.)(.)(?<b>.)/.match('qwerty')
+  INSTANCE2 = /u\K(?<a>a)?./.match('uiop')
+
+  def with_backref(name: 'a', idx: 1, &block)
+    yield name.to_s
+    yield name.to_sym
+    with_int(idx, &block)
+  end
+
+  def test_initalize_copy
+    instance = /./.match('&')
+
+    assert_send_type  '(MatchData) -> self',
+                      instance, :initialize_copy, INSTANCE
   end
 
-  # test_[]
-  def test_square_bracket
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~[0]
-    $~[3]
-    $~[0..3]
-    $~[0, 4]
-    $~['first']
-    $~['third']
-    $~[:first]
-    $~[:third]
+  def test_eq(method: :==)
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '(MatchData) -> bool',
+                        INSTANCE, method, instance
+    end
+
+    with_untyped.but MatchData do |untyped|
+      assert_send_type  '(untyped) -> false',
+                        INSTANCE, method, untyped
+    end
+  end
+
+  def test_aref
+    with_int 1 do |start|
+      with_int 2 do |length|
+        assert_send_type  '(int, int) -> Array[String]',
+                          INSTANCE, :[], start, length
+        assert_send_type  '(int, int) -> Array[nil]',
+                          INSTANCE2, :[], start, length
+      end
+    end
+
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> String',
+                        INSTANCE, :[], backref
+      assert_send_type  '(MatchData::capture, nil) -> String',
+                        INSTANCE, :[], backref, nil
+
+      assert_send_type  '(MatchData::capture) -> nil',
+                        INSTANCE2, :[], backref
+      assert_send_type  '(MatchData::capture, nil) -> nil',
+                        INSTANCE2, :[], backref, nil
+    end
+
+    with_range with_int(1).and_nil, with_int(2).and_nil do |range|
+      assert_send_type  '(range[int?]) -> Array[String]',
+                        INSTANCE, :[], range
+
+      # if the beginning is `nil`, then it'll include index `0`, which is the entire capture,
+      # and thus will be `Array[String?]`.
+      next if nil.equal?(range.begin)
+      assert_send_type  '(range[int?]) -> Array[String?]',
+                        INSTANCE2, :[], range
+    end
   end
 
-  # test_begin
   def test_begin
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.begin 0
-    $~.begin 3
-    $~.begin 'first'
-    $~.begin 'third'
-    $~.begin :first
-    $~.begin :third
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> Integer',
+                        INSTANCE, :begin, backref
+      assert_send_type  '(MatchData::capture) -> nil',
+                        INSTANCE2, :begin, backref
+    end
+  end
+
+  def test_byteoffset
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> [Integer, Integer]',
+                        INSTANCE, :byteoffset, backref
+      assert_send_type  '(MatchData::capture) -> [nil, nil]',
+                        INSTANCE2, :byteoffset, backref
+    end
   end
 
-  def test_caputres
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.captures
+  def test_captures(method: :captures)
+    assert_send_type  '() -> Array[String]',
+                      INSTANCE, method
+    assert_send_type  '() -> Array[nil]',
+                      INSTANCE2, method
+  end
+
+  def test_deconstruct
+    test_captures(method: :deconstruct)
+  end
+
+  def test_deconstruct_keys
+    assert_send_type  '(nil) -> Hash[Symbol, String]',
+                      INSTANCE, :deconstruct_keys, nil
+    assert_send_type  '(nil) -> Hash[Symbol, nil]',
+                      INSTANCE2, :deconstruct_keys, nil
+
+    assert_send_type  '(Array[Symbol]) -> Hash[Symbol, String]',
+                      INSTANCE, :deconstruct_keys, [:a]
+    assert_send_type  '(Array[Symbol]) -> Hash[Symbol, nil]',
+                      INSTANCE2, :deconstruct_keys, [:a]
   end
 
   def test_end
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.end 0
-    $~.end 3
-    $~.end 'first'
-    $~.end 'third'
-    $~.end :first
-    $~.end :third
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> Integer',
+                        INSTANCE, :end, backref
+      assert_send_type  '(MatchData::capture) -> nil',
+                        INSTANCE2, :end, backref
+    end
   end
 
   def test_eql?
-    foo = 'foo'
-    foo.match('f').eql? foo.match('f')
+    test_eq(method: :eql?)
   end
 
   def test_hash
-    'foo'.match('f').hash
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :hash
   end
 
   def test_inspect
-    'foo'.match('f').inspect
+    assert_send_type  '() -> String',
+                      INSTANCE, :inspect
   end
 
   def test_length
-    'foo'.match('f').length
+    test_size(method: :length)
   end
 
   def test_named_captures
-    'foo'.match('(?<a>foo)').named_captures
+    assert_send_type  '() -> Hash[String, String]',
+                      INSTANCE, :named_captures
+    assert_send_type  '() -> Hash[String, nil]',
+                      INSTANCE2, :named_captures
   end
 
   def test_names
-    'foo'.match('(?<a>foo)').names
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '() -> Array[String]',
+                        instance, :names
+    end
   end
 
   def test_match
-    m = /(.)(.)(\d+)(\d)(\w)?/.match("THX1138.")
-    m.match(0)
-    m.match(4.0)
-    m.match(ToInt.new(5))
-
-    m = /(?<foo>.)(.)(?<bar>.+)/.match("hoge")
-    m.match(:foo)
-    m.match("bar")
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> String',
+                        INSTANCE, :match, backref
+      assert_send_type  '(MatchData::capture) -> nil',
+                        INSTANCE2, :match, backref
+    end
   end
 
   def test_match_length
-    m = /(.)(.)(\d+)(\d)(\w)?/.match("THX1138.")
-    m.match_length(0)
-    m.match_length(4.0)
-    m.match_length(ToInt.new(5))
-
-    m = /(?<foo>.)(.)(?<bar>.+)/.match("hoge")
-    m.match_length(:foo)
-    m.match_length("bar")
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> Integer',
+                        INSTANCE, :match_length, backref
+      assert_send_type  '(MatchData::capture) -> nil',
+                        INSTANCE2, :match_length, backref
+    end
   end
 
   def test_offset
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.offset 0
-    $~.offset 3
-    $~.offset 'first'
-    $~.offset 'third'
-    $~.offset :first
-    $~.offset :third
+    with_backref do |backref|
+      assert_send_type  '(MatchData::capture) -> [Integer, Integer]',
+                        INSTANCE, :offset, backref
+      assert_send_type  '(MatchData::capture) -> [nil, nil]',
+                        INSTANCE2, :offset, backref
+    end
   end
 
   def test_post_match
-    'foo'.match('f').post_match
+    assert_send_type  '() -> String',
+                      INSTANCE, :post_match
   end
 
   def test_pre_match
-    'foo'.match('o').pre_match
+    assert_send_type  '() -> String',
+                      INSTANCE, :pre_match
   end
 
   def test_regexp
-    'foo'.match('f').regexp
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '() -> Regexp',
+                        instance, :regexp
+    end
   end
 
-  def test_size
-    'foo'.match('f').size
+  def test_size(method: :size)
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '() -> Integer',
+                        instance, :size
+    end
   end
 
   def test_string
-    'foo'.match('f').string
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '() -> String',
+                        instance, :string
+    end
   end
 
   def test_to_a
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.to_a
+    assert_send_type  '() -> Array[String]',
+                      INSTANCE, :to_a
+
+    # In `.to_a`, the first field is always non-nil.
+    assert_send_type  '() -> Array[String?]',
+                      INSTANCE2, :to_a
+    assert_type 'Array[nil]',
+                INSTANCE2.to_a[1..]
   end
 
   def test_to_s
-    'foo'.match('f').to_s
+    with INSTANCE, INSTANCE2 do |instance|
+      assert_send_type  '() -> String',
+                        instance, :to_s
+    end
   end
 
   def test_values_at
-    /(?<first>foo)(?<second>bar)(?<third>Baz)?/ =~ "foobarbaz"
-    $~.values_at 0
-    $~.values_at 3
-    $~.values_at 'first'
-    $~.values_at 'third'
-    $~.values_at :first
-    $~.values_at :third
+    with INSTANCE, INSTANCE2 do |instance|
+        assert_send_type  '(*MatchData::capture) -> []',
+                          instance, :values_at
+    end
+
+    with_backref do |backref|
+      with_range with_int(1).and_nil, with_int(2).and_nil do |range|
+        assert_send_type  '(*MatchData::capture | range[int?]) -> Array[String]',
+                          INSTANCE, :values_at, backref, range
+
+        # if the beginning is `nil`, then it'll include index `0`, which is the entire capture,
+        # and thus will be `Array[String?]`.
+        next if nil.equal?(range.begin)
+        assert_send_type  '(*MatchData::capture | range[int?]) -> Array[nil]',
+                          INSTANCE2, :values_at, backref, range
+      end
+    end
   end
 end