regexp_parser 2.1.1 → 2.2.0

data/lib/regexp_parser/syntax/token.rb

@@ -0,0 +1,45 @@
+# Define the base module and the simplest of tokens.
+module Regexp::Syntax
+  module Token
+    Map = {}
+
+    module Literal
+      All = %i[literal]
+      Type = :literal
+    end
+
+    module FreeSpace
+      All  = %i[comment whitespace]
+      Type = :free_space
+    end
+
+    Map[FreeSpace::Type] = FreeSpace::All
+    Map[Literal::Type]   = Literal::All
+  end
+end
+
+
+# Load all the token files, they will populate the Map constant.
+require 'regexp_parser/syntax/token/anchor'
+require 'regexp_parser/syntax/token/assertion'
+require 'regexp_parser/syntax/token/backreference'
+require 'regexp_parser/syntax/token/posix_class'
+require 'regexp_parser/syntax/token/character_set'
+require 'regexp_parser/syntax/token/character_type'
+require 'regexp_parser/syntax/token/conditional'
+require 'regexp_parser/syntax/token/escape'
+require 'regexp_parser/syntax/token/group'
+require 'regexp_parser/syntax/token/keep'
+require 'regexp_parser/syntax/token/meta'
+require 'regexp_parser/syntax/token/quantifier'
+require 'regexp_parser/syntax/token/unicode_property'
+
+
+# After loading all the tokens the map is full. Extract all tokens and types
+# into the All and Types constants.
+module Regexp::Syntax
+  module Token
+    All   = Map.values.flatten.uniq.sort.freeze
+    Types = Map.keys.freeze
+  end
+end

data/lib/regexp_parser/syntax/versions/1.8.6.rb

@@ -5,7 +5,7 @@ module Regexp::Syntax
 
       implements :anchor, Anchor::All
       implements :assertion, Assertion::Lookahead
-      implements :backref, [:number]
+      implements :backref, Backreference::Plain
       implements :posixclass, PosixClass::Standard
       implements :group, Group::All
       implements :meta, Meta::Extended

data/lib/regexp_parser/syntax/versions/3.1.0.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V3_1_0 < Regexp::Syntax::V2_6_3
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V3_1_0
+      implements :nonproperty, UnicodeProperty::V3_1_0
+    end
+  end
+end

data/lib/regexp_parser/syntax.rb

@@ -4,7 +4,7 @@ module Regexp::Syntax
   class SyntaxError < Regexp::Parser::Error; end
 end
 
-require_relative 'syntax/tokens'
+require_relative 'syntax/token'
 require_relative 'syntax/base'
 require_relative 'syntax/any'
 require_relative 'syntax/version_lookup'

data/lib/regexp_parser/token.rb

@@ -1,14 +1,13 @@
 class Regexp
-
-  TOKEN_KEYS = [
-    :type,
-    :token,
-    :text,
-    :ts,
-    :te,
-    :level,
-    :set_level,
-    :conditional_level
+  TOKEN_KEYS = %i[
+    type
+    token
+    text
+    ts
+    te
+    level
+    set_level
+    conditional_level
   ].freeze
 
   Token = Struct.new(*TOKEN_KEYS) do
@@ -21,15 +20,5 @@ class Regexp
     def length
       te - ts
     end
-
-    if RUBY_VERSION < '2.0.0'
-      def to_h
-        members.inject({}) do |hash, member|
-          hash[member.to_sym] = self[member]
-          hash
-        end
-      end
-    end
   end
-
 end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '2.1.1'
+    VERSION = '2.2.0'
   end
 end

data/lib/regexp_parser.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'regexp_parser/version'
 require 'regexp_parser/token'
 require 'regexp_parser/scanner'

data/spec/lexer/nesting_spec.rb

@@ -59,7 +59,7 @@ RSpec.describe('Nesting lexing') do
     4 => [:literal,     :literal,       'e',      4,  5, 0, 1, 0],
     5 => [:set,         :close,         ']',      5,  6, 0, 0, 0]
 
-  include_examples 'lex', /[[:word:]&&[^c]z]/,
+  include_examples 'lex', '[[:word:]&&[^c]z]',
     0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
     1 => [:posixclass,  :word,          '[:word:]',   1,  9, 0, 1, 0],
     2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],
@@ -70,7 +70,7 @@ RSpec.describe('Nesting lexing') do
     7 => [:literal,     :literal,       'z',         15, 16, 0, 1, 0],
     8 => [:set,         :close,         ']',         16, 17, 0, 0, 0]
 
-  include_examples 'lex', /[\p{word}&&[^c]z]/,
+  include_examples 'lex', '[\p{word}&&[^c]z]',
     0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
     1 => [:property,    :word,          '\p{word}',   1,  9, 0, 1, 0],
     2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],

data/spec/parser/escapes_spec.rb

@@ -56,8 +56,20 @@ RSpec.describe('EscapeSequence parsing') do
     expect { root[5].codepoint }.to raise_error(/#codepoints/)
   end
 
+  # Meta/control espaces
+  #
+  # After the following fix in Ruby 3.1, a Regexp#source containing meta/control
+  # escapes can only be set with the Regexp::new constructor.
+  # In Regexp literals, these escapes are now pre-processed to hex escapes.
+  #
+  # https://github.com/ruby/ruby/commit/11ae581a4a7f5d5f5ec6378872eab8f25381b1b9
+  def parse_meta_control(regexp_body)
+    regexp = Regexp.new(regexp_body.force_encoding('ascii-8bit'), 'n')
+    RP.parse(regexp)
+  end
+
   specify('parse escape control sequence lower') do
-    root = RP.parse(/a\\\c2b/)
+    root = parse_meta_control('a\\\\\c2b')
 
     expect(root[2]).to be_instance_of(EscapeSequence::Control)
     expect(root[2].text).to eq '\\c2'
@@ -66,56 +78,56 @@ RSpec.describe('EscapeSequence parsing') do
   end
 
   specify('parse escape control sequence upper') do
-    root = RP.parse(/\d\\\C-C\w/)
+    root = parse_meta_control('\d\C-C\w')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::Control)
-    expect(root[2].text).to eq '\\C-C'
-    expect(root[2].char).to eq "\x03"
-    expect(root[2].codepoint).to eq 3
+    expect(root[1]).to be_instance_of(EscapeSequence::Control)
+    expect(root[1].text).to eq '\\C-C'
+    expect(root[1].char).to eq "\x03"
+    expect(root[1].codepoint).to eq 3
   end
 
   specify('parse escape meta sequence') do
-    root = RP.parse(/\Z\\\M-Z/n)
+    root = parse_meta_control('\Z\M-Z')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::Meta)
-    expect(root[2].text).to eq '\\M-Z'
-    expect(root[2].char).to eq "\u00DA"
-    expect(root[2].codepoint).to eq 218
+    expect(root[1]).to be_instance_of(EscapeSequence::Meta)
+    expect(root[1].text).to eq '\\M-Z'
+    expect(root[1].char).to eq "\u00DA"
+    expect(root[1].codepoint).to eq 218
   end
 
   specify('parse escape meta control sequence') do
-    root = RP.parse(/\A\\\M-\C-X/n)
+    root = parse_meta_control('\A\M-\C-X')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::MetaControl)
-    expect(root[2].text).to eq '\\M-\\C-X'
-    expect(root[2].char).to eq "\u0098"
-    expect(root[2].codepoint).to eq 152
+    expect(root[1]).to be_instance_of(EscapeSequence::MetaControl)
+    expect(root[1].text).to eq '\\M-\\C-X'
+    expect(root[1].char).to eq "\u0098"
+    expect(root[1].codepoint).to eq 152
   end
 
   specify('parse lower c meta control sequence') do
-    root = RP.parse(/\A\\\M-\cX/n)
+    root = parse_meta_control('\A\M-\cX')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::MetaControl)
-    expect(root[2].text).to eq '\\M-\\cX'
-    expect(root[2].char).to eq "\u0098"
-    expect(root[2].codepoint).to eq 152
+    expect(root[1]).to be_instance_of(EscapeSequence::MetaControl)
+    expect(root[1].text).to eq '\\M-\\cX'
+    expect(root[1].char).to eq "\u0098"
+    expect(root[1].codepoint).to eq 152
   end
 
   specify('parse escape reverse meta control sequence') do
-    root = RP.parse(/\A\\\C-\M-X/n)
+    root = parse_meta_control('\A\C-\M-X')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::MetaControl)
-    expect(root[2].text).to eq '\\C-\\M-X'
-    expect(root[2].char).to eq "\u0098"
-    expect(root[2].codepoint).to eq 152
+    expect(root[1]).to be_instance_of(EscapeSequence::MetaControl)
+    expect(root[1].text).to eq '\\C-\\M-X'
+    expect(root[1].char).to eq "\u0098"
+    expect(root[1].codepoint).to eq 152
   end
 
   specify('parse escape reverse lower c meta control sequence') do
-    root = RP.parse(/\A\\\c\M-X/n)
+    root = parse_meta_control('\A\c\M-X')
 
-    expect(root[2]).to be_instance_of(EscapeSequence::MetaControl)
-    expect(root[2].text).to eq '\\c\\M-X'
-    expect(root[2].char).to eq "\u0098"
-    expect(root[2].codepoint).to eq 152
+    expect(root[1]).to be_instance_of(EscapeSequence::MetaControl)
+    expect(root[1].text).to eq '\\c\\M-X'
+    expect(root[1].char).to eq "\u0098"
+    expect(root[1].codepoint).to eq 152
   end
 end

data/spec/parser/properties_spec.rb

@@ -37,11 +37,13 @@ RSpec.describe('Property parsing') do
     end
   end
 
-  specify('parse all properties of current ruby') do
-    unsupported = RegexpPropertyValues.all_for_current_ruby.reject do |prop|
-      RP.parse("\\p{#{prop}}") rescue false
+  if ruby_version_at_least('2.7.0')
+    specify('parse all properties of current ruby') do
+      unsupported = RegexpPropertyValues.all_for_current_ruby.reject do |prop|
+        RP.parse("\\p{#{prop}}") rescue false
+      end
+      expect(unsupported).to be_empty
     end
-    expect(unsupported).to be_empty
   end
 
   specify('parse property negative') do

data/spec/parser/set/ranges_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 RSpec.describe('CharacterSet::Range parsing') do
+  # Some edge-case patterns are evaluated with #match to make sure that
+  # their behavior still reflects the way they are parsed.
+  # #capturing_stderr is used to skip any warnings generated by this.
+
   specify('parse set range') do
     root = RP.parse('[a-z]')
     set = root[0]
@@ -13,7 +17,7 @@ RSpec.describe('CharacterSet::Range parsing') do
     expect(range.first).to be_instance_of(Literal)
     expect(range.last.to_s).to eq 'z'
     expect(range.last).to be_instance_of(Literal)
-    expect(set).to match 'm'
+    capturing_stderr { expect(set).to match 'm' }
   end
 
   specify('parse set range hex') do
@@ -28,7 +32,7 @@ RSpec.describe('CharacterSet::Range parsing') do
     expect(range.first).to be_instance_of(EscapeSequence::Hex)
     expect(range.last.to_s).to eq '\\x22'
     expect(range.last).to be_instance_of(EscapeSequence::Hex)
-    expect(set).to match "\x11"
+    capturing_stderr { expect(set).to match "\x11" }
   end
 
   specify('parse set range unicode') do
@@ -43,7 +47,7 @@ RSpec.describe('CharacterSet::Range parsing') do
     expect(range.first).to be_instance_of(EscapeSequence::CodepointList)
     expect(range.last.to_s).to eq '\\u1234'
     expect(range.last).to be_instance_of(EscapeSequence::Codepoint)
-    expect(set).to match '\\u600'
+    capturing_stderr { expect(set).to match '\\u600' }
   end
 
   specify('parse set range edge case leading dash') do
@@ -53,7 +57,7 @@ RSpec.describe('CharacterSet::Range parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set).to match 'a'
+    capturing_stderr { expect(set).to match 'a' }
   end
 
   specify('parse set range edge case trailing dash') do
@@ -63,7 +67,7 @@ RSpec.describe('CharacterSet::Range parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set).to match '$'
+    capturing_stderr { expect(set).to match '$' }
   end
 
   specify('parse set range edge case leading negate') do
@@ -71,8 +75,10 @@ RSpec.describe('CharacterSet::Range parsing') do
     set = root[0]
 
     expect(set.count).to eq 2
-    expect(set).to     match 'a'
-    expect(set).not_to match 'z'
+    capturing_stderr do
+      expect(set).to     match 'a'
+      expect(set).not_to match 'z'
+    end
   end
 
   specify('parse set range edge case trailing negate') do
@@ -82,7 +88,7 @@ RSpec.describe('CharacterSet::Range parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set).to match '$'
+    capturing_stderr { expect(set).to match '$' }
   end
 
   specify('parse set range edge case leading intersection') do
@@ -91,10 +97,12 @@ RSpec.describe('CharacterSet::Range parsing') do
 
     expect(set.count).to eq 1
     expect(set.first.last.to_s).to eq '-bc'
-    expect(set).to     match '-'
-    expect(set).to     match 'b'
-    expect(set).not_to match 'a'
-    expect(set).not_to match 'c'
+    capturing_stderr do
+      expect(set).to     match '-'
+      expect(set).to     match 'b'
+      expect(set).not_to match 'a'
+      expect(set).not_to match 'c'
+    end
   end
 
   specify('parse set range edge case trailing intersection') do
@@ -103,9 +111,11 @@ RSpec.describe('CharacterSet::Range parsing') do
 
     expect(set.count).to eq 1
     expect(set.first.first.to_s).to eq 'bc-'
-    expect(set).to     match '-'
-    expect(set).to     match 'b'
-    expect(set).not_to match 'a'
-    expect(set).not_to match 'c'
+    capturing_stderr do
+      expect(set).to     match '-'
+      expect(set).to     match 'b'
+      expect(set).not_to match 'a'
+      expect(set).not_to match 'c'
+    end
   end
 end

data/spec/scanner/escapes_spec.rb

@@ -35,25 +35,6 @@ RSpec.describe('Escape scanning') do
   include_examples 'scan', 'a\u{640 0641}c',  1 => [:escape,  :codepoint_list,   '\u{640 0641}',   1,  13]
   include_examples 'scan', 'a\u{10FFFF}c',    1 => [:escape,  :codepoint_list,   '\u{10FFFF}',     1,  11]
 
-  include_examples 'scan', /a\cBc/,           1 => [:escape,  :control,          '\cB',            1,  4]
-  include_examples 'scan', /a\c^c/,           1 => [:escape,  :control,          '\c^',            1,  4]
-  include_examples 'scan', /a\c\n/,           1 => [:escape,  :control,          '\c\n',           1,  5]
-  include_examples 'scan', /a\c\\b/,          1 => [:escape,  :control,          '\c\\\\',         1,  5]
-  include_examples 'scan', /a\C-bc/,          1 => [:escape,  :control,          '\C-b',           1,  5]
-  include_examples 'scan', /a\C-^b/,          1 => [:escape,  :control,          '\C-^',           1,  5]
-  include_examples 'scan', /a\C-\nb/,         1 => [:escape,  :control,          '\C-\n',          1,  6]
-  include_examples 'scan', /a\C-\\b/,         1 => [:escape,  :control,          '\C-\\\\',        1,  6]
-  include_examples 'scan', /a\c\M-Bc/n,       1 => [:escape,  :control,          '\c\M-B',         1,  7]
-  include_examples 'scan', /a\C-\M-Bc/n,      1 => [:escape,  :control,          '\C-\M-B',        1,  8]
-
-  include_examples 'scan', /a\M-Bc/n,         1 => [:escape,  :meta_sequence,    '\M-B',           1,  5]
-  include_examples 'scan', /a\M-\cBc/n,       1 => [:escape,  :meta_sequence,    '\M-\cB',         1,  7]
-  include_examples 'scan', /a\M-\c^/n,        1 => [:escape,  :meta_sequence,    '\M-\c^',         1,  7]
-  include_examples 'scan', /a\M-\c\n/n,       1 => [:escape,  :meta_sequence,    '\M-\c\n',        1,  8]
-  include_examples 'scan', /a\M-\c\\/n,       1 => [:escape,  :meta_sequence,    '\M-\c\\\\',      1,  8]
-  include_examples 'scan', /a\M-\C-Bc/n,      1 => [:escape,  :meta_sequence,    '\M-\C-B',        1,  8]
-  include_examples 'scan', /a\M-\C-\\/n,      1 => [:escape,  :meta_sequence,    '\M-\C-\\\\',     1,  9]
-
   include_examples 'scan', 'ab\\\xcd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
   include_examples 'scan', 'ab\\\0cd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
   include_examples 'scan', 'ab\\\Kcd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
@@ -61,4 +42,32 @@ RSpec.describe('Escape scanning') do
   include_examples 'scan', 'ab\^cd',          1 => [:escape,  :bol,              '\^',             2,  4]
   include_examples 'scan', 'ab\$cd',          1 => [:escape,  :eol,              '\$',             2,  4]
   include_examples 'scan', 'ab\[cd',          1 => [:escape,  :set_open,         '\[',             2,  4]
+
+  # Meta/control espaces
+  #
+  # After the following fix in Ruby 3.1, a Regexp#source containing meta/control
+  # escapes can only be set with the Regexp::new constructor.
+  # In Regexp literals, these escapes are now pre-processed to hex escapes.
+  #
+  # https://github.com/ruby/ruby/commit/11ae581a4a7f5d5f5ec6378872eab8f25381b1b9
+  n = ->(regexp_body){ Regexp.new(regexp_body.force_encoding('ascii-8bit'), 'n') }
+
+  include_examples 'scan', 'a\cBc',           1 => [:escape,  :control,          '\cB',            1,  4]
+  include_examples 'scan', 'a\c^c',           1 => [:escape,  :control,          '\c^',            1,  4]
+  include_examples 'scan', 'a\c\n',           1 => [:escape,  :control,          '\c\n',           1,  5]
+  include_examples 'scan', 'a\c\\\\b',        1 => [:escape,  :control,          '\c\\\\',         1,  5]
+  include_examples 'scan', 'a\C-bc',          1 => [:escape,  :control,          '\C-b',           1,  5]
+  include_examples 'scan', 'a\C-^b',          1 => [:escape,  :control,          '\C-^',           1,  5]
+  include_examples 'scan', 'a\C-\nb',         1 => [:escape,  :control,          '\C-\n',          1,  6]
+  include_examples 'scan', 'a\C-\\\\b',       1 => [:escape,  :control,          '\C-\\\\',        1,  6]
+  include_examples 'scan', n.('a\c\M-Bc'),    1 => [:escape,  :control,          '\c\M-B',         1,  7]
+  include_examples 'scan', n.('a\C-\M-Bc'),   1 => [:escape,  :control,          '\C-\M-B',        1,  8]
+
+  include_examples 'scan', n.('a\M-Bc'),      1 => [:escape,  :meta_sequence,    '\M-B',           1,  5]
+  include_examples 'scan', n.('a\M-\cBc'),    1 => [:escape,  :meta_sequence,    '\M-\cB',         1,  7]
+  include_examples 'scan', n.('a\M-\c^'),     1 => [:escape,  :meta_sequence,    '\M-\c^',         1,  7]
+  include_examples 'scan', n.('a\M-\c\n'),    1 => [:escape,  :meta_sequence,    '\M-\c\n',        1,  8]
+  include_examples 'scan', n.('a\M-\c\\\\'),  1 => [:escape,  :meta_sequence,    '\M-\c\\\\',      1,  8]
+  include_examples 'scan', n.('a\M-\C-Bc'),   1 => [:escape,  :meta_sequence,    '\M-\C-B',        1,  8]
+  include_examples 'scan', n.('a\M-\C-\\\\'), 1 => [:escape,  :meta_sequence,    '\M-\C-\\\\',     1,  9]
 end

data/spec/scanner/sets_spec.rb

@@ -96,21 +96,21 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[&&z]/,                 1 => [:set,    :intersection,    '&&',         1, 3]
   include_examples 'scan', /[&&]/,                  1 => [:set,    :intersection,    '&&',         1, 3]
 
-  include_examples 'scan', /[a\p{digit}c]/,         2 => [:property,    :digit,      '\p{digit}',  2, 11]
-  include_examples 'scan', /[a\P{digit}c]/,         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
-  include_examples 'scan', /[a\p{^digit}c]/,        2 => [:nonproperty, :digit,      '\p{^digit}', 2, 12]
-  include_examples 'scan', /[a\P{^digit}c]/,        2 => [:property,    :digit,      '\P{^digit}', 2, 12]
+  include_examples 'scan', '[a\p{digit}c]',         2 => [:property,    :digit,      '\p{digit}',  2, 11]
+  include_examples 'scan', '[a\P{digit}c]',         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
+  include_examples 'scan', '[a\p{^digit}c]',        2 => [:nonproperty, :digit,      '\p{^digit}', 2, 12]
+  include_examples 'scan', '[a\P{^digit}c]',        2 => [:property,    :digit,      '\P{^digit}', 2, 12]
 
-  include_examples 'scan', /[a\p{ALPHA}c]/,         2 => [:property,    :alpha,      '\p{ALPHA}',  2, 11]
-  include_examples 'scan', /[a\p{P}c]/,             2 => [:property,    :punctuation,'\p{P}',      2, 7]
-  include_examples 'scan', /[a\p{P}\P{P}c]/,        3 => [:nonproperty, :punctuation,'\P{P}',      7, 12]
+  include_examples 'scan', '[a\p{ALPHA}c]',         2 => [:property,    :alpha,      '\p{ALPHA}',  2, 11]
+  include_examples 'scan', '[a\p{P}c]',             2 => [:property,    :punctuation,'\p{P}',      2, 7]
+  include_examples 'scan', '[a\p{P}\P{P}c]',        3 => [:nonproperty, :punctuation,'\P{P}',      7, 12]
 
-  include_examples 'scan', /[\x20-\x27]/,
+  include_examples 'scan', '[\x20-\x27]',
     1 => [:escape, :hex,             '\x20',       1, 5],
     2 => [:set,    :range,           '-',          5, 6],
     3 => [:escape, :hex,             '\x27',       6, 10]
 
-  include_examples 'scan', /[a-w&&[^c-g]z]/,
+  include_examples 'scan', '[a-w&&[^c-g]z]',
     5 => [:set,    :open,            '[',          6, 7],
     6 => [:set,    :negate,          '^',          7, 8],
     8 => [:set,    :range,           '-',          9, 10],

data/spec/spec_helper.rb

@@ -1,8 +1,13 @@
+$VERBOSE = true
+
 require 'ice_nine'
-require 'regexp_parser'
 require 'regexp_property_values'
+require_relative 'support/capturing_stderr'
 require_relative 'support/shared_examples'
 
+req_warn = capturing_stderr { require('regexp_parser') || fail('pre-required') }
+req_warn.empty? || fail("requiring parser generated warnings:\n#{req_warn}")
+
 RS = Regexp::Scanner
 RL = Regexp::Lexer
 RP = Regexp::Parser
@@ -14,3 +19,10 @@ include Regexp::Expression
 def ruby_version_at_least(version)
   Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new(version)
 end
+
+RSpec.configure do |config|
+  config.around(:example) do |example|
+    # treat unexpected warnings as failures
+    expect { example.run }.not_to output.to_stderr
+  end
+end

data/spec/support/capturing_stderr.rb

@@ -0,0 +1,9 @@
+require 'stringio'
+
+def capturing_stderr(&block)
+  old_stderr, $stderr = $stderr, StringIO.new
+  block.call
+  $stderr.string
+ensure
+  $stderr = old_stderr
+end

data/spec/syntax/versions/1.8.6_spec.rb

@@ -4,14 +4,14 @@ RSpec.describe(Regexp::Syntax::V1_8_6) do
   include_examples 'syntax', Regexp::Syntax.new('ruby/1.8.6'),
   implements: {
     assertion: T::Assertion::Lookahead,
-    backref: [:number],
+    backref: T::Backreference::Plain,
     escape: T::Escape::Basic + T::Escape::ASCII + T::Escape::Meta + T::Escape::Control,
     group: T::Group::V1_8_6,
     quantifier: T::Quantifier::Greedy + T::Quantifier::Reluctant + T::Quantifier::Interval + T::Quantifier::IntervalReluctant
   },
   excludes: {
     assertion: T::Assertion::Lookbehind,
-    backref: T::Backreference::All - [:number] + T::SubexpressionCall::All,
+    backref: T::Backreference::All - T::Backreference::Plain + T::SubexpressionCall::All,
     quantifier: T::Quantifier::Possessive
   }
 end

data/spec/syntax/versions/2.0.0_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe(Regexp::Syntax::V2_0_0) do
     nonproperty: T::UnicodeProperty::Age_V2_0_0
   },
   excludes: {
-    property: [:newline],
-    nonproperty: [:newline]
+    property: %i[newline],
+    nonproperty: %i[newline]
   }
 end

data/spec/syntax/versions/aliases_spec.rb

@@ -28,6 +28,7 @@ RSpec.describe(Regexp::Syntax) do
   include_examples 'syntax alias', 'ruby/2.6.2',  Regexp::Syntax::V2_6_2
   include_examples 'syntax alias', 'ruby/2.6.3',  Regexp::Syntax::V2_6_3
   include_examples 'syntax alias', 'ruby/2.6',    Regexp::Syntax::V2_6_3
+  include_examples 'syntax alias', 'ruby/3.1',    Regexp::Syntax::V3_1_0
 
   specify('future alias warning') do
     expect { Regexp::Syntax.new('ruby/5.0') }