Remove various other ruby version guards

Author: Earlopain

test/rbs/runtime_prototype_test.rb

@@ -775,74 +775,72 @@ class StructDirectInherited < ::Struct[untyped]
     end
   end
 
-  if RUBY_VERSION >= '3.2'
-    class DataInherit < Data.define(:foo, :bar, :baz?)
-    end
-    DataConst = Data.define(:foo, :bar)
-    class DataDirectInherit < Data
-    end
+  class DataInherit < Data.define(:foo, :bar, :baz?)
+  end
+  DataConst = Data.define(:foo, :bar)
+  class DataDirectInherit < Data
+  end
 
-    def test_data
-      SignatureManager.new do |manager|
-        manager.build do |env|
-          p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataInherit"], env: env, merge: false)
-          assert_write p.decls, <<~RBS
-            module RBS
-              class RuntimePrototypeTest < ::Test::Unit::TestCase
-                class DataInherit < ::Data
-                  def self.new: (untyped foo, untyped bar, untyped `baz?`) -> instance
-                              | (foo: untyped, bar: untyped, baz?: untyped) -> instance
+  def test_data
+    SignatureManager.new do |manager|
+      manager.build do |env|
+        p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataInherit"], env: env, merge: false)
+        assert_write p.decls, <<~RBS
+          module RBS
+            class RuntimePrototypeTest < ::Test::Unit::TestCase
+              class DataInherit < ::Data
+                def self.new: (untyped foo, untyped bar, untyped `baz?`) -> instance
+                            | (foo: untyped, bar: untyped, baz?: untyped) -> instance
 
-                  def self.[]: (untyped foo, untyped bar, untyped `baz?`) -> instance
-                             | (foo: untyped, bar: untyped, baz?: untyped) -> instance
+                def self.[]: (untyped foo, untyped bar, untyped `baz?`) -> instance
+                           | (foo: untyped, bar: untyped, baz?: untyped) -> instance
 
-                  def self.members: () -> [ :foo, :bar, :baz? ]
+                def self.members: () -> [ :foo, :bar, :baz? ]
 
-                  def members: () -> [ :foo, :bar, :baz? ]
+                def members: () -> [ :foo, :bar, :baz? ]
 
-                  attr_reader foo: untyped
+                attr_reader foo: untyped
 
-                  attr_reader bar: untyped
+                attr_reader bar: untyped
 
-                  attr_reader baz?: untyped
-                end
+                attr_reader baz?: untyped
               end
             end
-          RBS
+          end
+        RBS
 
-          p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataConst"], env: env, merge: false)
-          assert_write p.decls, <<~RBS
-            module RBS
-              class RuntimePrototypeTest < ::Test::Unit::TestCase
-                class DataConst < ::Data
-                  def self.new: (untyped foo, untyped bar) -> instance
-                              | (foo: untyped, bar: untyped) -> instance
+        p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataConst"], env: env, merge: false)
+        assert_write p.decls, <<~RBS
+          module RBS
+            class RuntimePrototypeTest < ::Test::Unit::TestCase
+              class DataConst < ::Data
+                def self.new: (untyped foo, untyped bar) -> instance
+                            | (foo: untyped, bar: untyped) -> instance
 
-                  def self.[]: (untyped foo, untyped bar) -> instance
-                             | (foo: untyped, bar: untyped) -> instance
+                def self.[]: (untyped foo, untyped bar) -> instance
+                           | (foo: untyped, bar: untyped) -> instance
 
-                  def self.members: () -> [ :foo, :bar ]
+                def self.members: () -> [ :foo, :bar ]
 
-                  def members: () -> [ :foo, :bar ]
+                def members: () -> [ :foo, :bar ]
 
-                  attr_reader foo: untyped
+                attr_reader foo: untyped
 
-                  attr_reader bar: untyped
-                end
+                attr_reader bar: untyped
               end
             end
-          RBS
+          end
+        RBS
 
-          p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataDirectInherit"], env: env, merge: false)
-          assert_write p.decls, <<~RBS
-            module RBS
-              class RuntimePrototypeTest < ::Test::Unit::TestCase
-                class DataDirectInherit < ::Data
-                end
+        p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::DataDirectInherit"], env: env, merge: false)
+        assert_write p.decls, <<~RBS
+          module RBS
+            class RuntimePrototypeTest < ::Test::Unit::TestCase
+              class DataDirectInherit < ::Data
               end
             end
-          RBS
-        end
+          end
+        RBS
       end
     end
   end

test/rbs/test/runtime_test_test.rb

@@ -2,8 +2,6 @@
 require "rbs/test"
 require "logger"
 
-return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
-
 class RBS::Test::RuntimeTestTest < Test::Unit::TestCase
   omit_on_truffle_ruby! "`rbs test` relies on `TracePoint` `:end` event, which is not supported on TruffleRuby"
   omit_on_jruby! "`rbs test` relies on `TracePoint` `:end` event, which is not supported on JRuby"

test/stdlib/Regexp_test.rb

@@ -51,14 +51,6 @@ def test_compile
         assert_send_type  '(string, int | string | bool | nil) -> Regexp',
                           Regexp, :compile, pattern, options
 
-        # In older versions of ruby, `Regexp.{new,compile}` could take an additional third argument,
-        # which indicated "no encoding". Due to weirdnesses with how keyword arguments are passed
-        # around in Ruby, along with how `compile` is registered internally, the `timeout: _ToF?`
-        # argument is interpreted as this optional third argument in older versions. So, to prevent
-        # any issues, this `next` skips it. Note that this issue doesn't occur in `test_initialize`
-        # because the implicit argument passing isn't done.
-        next if RUBY_VERSION < '3.3'
-
         with_float(12.34).and_nil do |timeout|
           assert_send_type  '(string, int | string | bool | nil, timeout: _ToF?) -> Regexp',
                             Regexp, :compile, pattern, options, timeout: timeout
@@ -149,8 +141,6 @@ def (toregexp = BlankSlate.new).to_regexp = /a/
   end
 
   def test_timeout
-    omit_if RUBY_VERSION < '3.2'
-
     begin
       old_timeout = Regexp.timeout
 
@@ -167,8 +157,6 @@ def test_timeout
   end
 
   def test_timeout=
-    omit_if RUBY_VERSION < '3.2'
-
     begin
       old_timeout = Regexp.timeout
 

test/stdlib/RubyVM_test.rb

@@ -21,11 +21,9 @@ def test_of
                      RubyVM::AbstractSyntaxTree, :of, method(:test_of)
   end
 
-  if RUBY_VERSION >= '3.2'
-    def test_node_id_for_backtrace_location
-      assert_send_type "(::Thread::Backtrace::Location backtrace_location) -> ::Integer",
-                      RubyVM::AbstractSyntaxTree, :node_id_for_backtrace_location, caller_locations[0]
-    end
+  def test_node_id_for_backtrace_location
+    assert_send_type "(::Thread::Backtrace::Location backtrace_location) -> ::Integer",
+                    RubyVM::AbstractSyntaxTree, :node_id_for_backtrace_location, caller_locations[0]
   end
 end
 
@@ -66,16 +64,14 @@ def test_locations
     end
   end
 
-  if RUBY_VERSION >= '3.2'
-    def test_tokens
-      assert_send_type "() -> ::Array[[ ::Integer, ::Symbol, ::String, [ ::Integer, ::Integer, ::Integer, ::Integer ] ]]?",
-                      RubyVM::AbstractSyntaxTree.parse("1 + 2", keep_tokens: true), :tokens
-    end
+  def test_tokens
+    assert_send_type "() -> ::Array[[ ::Integer, ::Symbol, ::String, [ ::Integer, ::Integer, ::Integer, ::Integer ] ]]?",
+                    RubyVM::AbstractSyntaxTree.parse("1 + 2", keep_tokens: true), :tokens
+  end
 
-    def test_all_tokens
-      assert_send_type "() -> ::Array[[ ::Integer, ::Symbol, ::String, [ ::Integer, ::Integer, ::Integer, ::Integer ] ]]?",
-                      RubyVM::AbstractSyntaxTree.parse("1 + 2", keep_tokens: true), :all_tokens
-    end
+  def test_all_tokens
+    assert_send_type "() -> ::Array[[ ::Integer, ::Symbol, ::String, [ ::Integer, ::Integer, ::Integer, ::Integer ] ]]?",
+                    RubyVM::AbstractSyntaxTree.parse("1 + 2", keep_tokens: true), :all_tokens
   end
 
   def test_children

test/stdlib/String_test.rb

@@ -323,8 +323,6 @@ def test_b
   end
 
   def test_byteindex
-    omit_if RUBY_VERSION < '3.2'
-
     with_string('e').and /e/ do |pattern|
       assert_send_type  '(Regexp | string) -> Integer',
                         'hello', :byteindex, pattern
@@ -341,8 +339,6 @@ def test_byteindex
   end
 
   def test_byterindex
-    omit_if RUBY_VERSION < '3.2'
-
     with_string('e').and /e/ do |pattern|
       assert_send_type  '(Regexp | string) -> Integer',
                         'hello', :byterindex, pattern
@@ -389,32 +385,22 @@ def test_byteslice
   end
 
   def test_bytesplice
-    omit_if(RUBY_VERSION < '3.2', 'String#bytesplice was added in 3.2')
-
-    # In 3.3 and onwards (and backported to 3.2.16), the return type is `self`. This variable
-    # is in case the test suite is run in a version under 3.2.16; tests for the variants only
-    # supported in 3.3 and onwards use `self`. If we ever stop supporting 3.2, we can remove this.
-
     with_string ', world! :-D' do |string|
       assert_send_type  "(Integer, Integer, string) -> String",
                         +'hello', :bytesplice,  1, 2, string
 
-      if RUBY_VERSION >= "3.3.0"
-        with_int 1 do |start|
-          assert_send_type  '(int, Integer, string, Integer, Integer) -> String',
-                            +'hello', :bytesplice,  start, 2, string, 3, 4
-        end
+      with_int 1 do |start|
+        assert_send_type  '(int, Integer, string, Integer, Integer) -> String',
+                          +'hello', :bytesplice,  start, 2, string, 3, 4
       end
 
       with_range with_int(1).and_nil, with_int(2).and_nil do |range|
         assert_send_type  "(range[int?], string) -> String",
                           +'hello', :bytesplice, range, string
 
-        if RUBY_VERSION >= '3.3.0'
-          with_range with_int(3).and_nil, with_int(4).and_nil do |string_range|
-            assert_send_type  '(range[int?], string, range[int?]) -> String',
-                              +'hello', :bytesplice, range, string, string_range
-          end
+        with_range with_int(3).and_nil, with_int(4).and_nil do |string_range|
+          assert_send_type  '(range[int?], string, range[int?]) -> String',
+                            +'hello', :bytesplice, range, string, string_range
         end
       end
     end
@@ -574,7 +560,6 @@ def test_count
   end
 
   def test_dedup
-    omit_if RUBY_VERSION < '3.2.0'
     test_uneg :dedup
   end
 

test/stdlib/Warning_test.rb

@@ -1,7 +1,6 @@
 require_relative "test_helper"
 
-WARNING_CATEGORIES = %i[deprecated experimental]
-WARNING_CATEGORIES << :performance if RUBY_VERSION >= '3.3'
+WARNING_CATEGORIES = %i[deprecated experimental performance]
 
 class WarningSingletonTest < Test::Unit::TestCase
   include TestHelper