regexp_parser 2.0.3 → 2.1.0

data/lib/regexp_parser/scanner/scanner.rl

@@ -20,7 +20,7 @@
 
   group_open            = '(';
   group_close           = ')';
-  parantheses           = group_open | group_close;
+  parentheses           = group_open | group_close;
 
   set_open              = '[';
   set_close             = ']';
@@ -58,6 +58,8 @@
 
   meta_sequence         = 'M-' . (backslash . ('c' | 'C-'))? . backslash? . any;
 
+  sequence_char         = [CMcux];
+
   zero_or_one           = '?' | '??' | '?+';
   zero_or_more          = '*' | '*?' | '*+';
   one_or_more           = '+' | '+?' | '++';
@@ -106,11 +108,15 @@
 
   group_named           = ('?' . group_name );
 
-  group_name_ref        = group_ref . (('<' . group_name_id_ab? . group_level? '>') |
-                                       ("'" . group_name_id_sq? . group_level? "'"));
+  group_name_backref    = 'k' . (('<' . group_name_id_ab? . group_level? '>') |
+                                 ("'" . group_name_id_sq? . group_level? "'"));
+  group_name_call       = 'g' . (('<' . group_name_id_ab? . group_level? '>') |
+                                 ("'" . group_name_id_sq? . group_level? "'"));
 
-  group_number_ref      = group_ref . (('<' . group_number . group_level? '>') |
-                                       ("'" . group_number . group_level? "'"));
+  group_number_backref  = 'k' . (('<' . group_number . group_level? '>') |
+                                 ("'" . group_number . group_level? "'"));
+  group_number_call     = 'g' . (('<' . ((group_number . group_level?) | '0') '>') |
+                                 ("'" . ((group_number . group_level?) | '0') "'"));
 
   group_type            = group_atomic | group_passive | group_absence | group_named;
 
@@ -121,7 +127,7 @@
 
   # characters that 'break' a literal
   meta_char             = dot | backslash | alternation |
-                          curlies | parantheses | brackets |
+                          curlies | parentheses | brackets |
                           line_anchor | quantifier_greedy;
 
   literal_delimiters    = ']' | '}';
@@ -130,10 +136,12 @@
   ascii_nonprint        = (0x01..0x1f | 0x7f);
 
   non_literal_escape    = char_type_char | anchor_char | escaped_ascii |
-                          keep_mark | [xucCM];
+                          keep_mark | sequence_char;
+
+  # escapes that also work within a character set
+  set_escape            = backslash | brackets | escaped_ascii | property_char |
+                          sequence_char | single_codepoint_char_type;
 
-  non_set_escape        = (anchor_char - 'b') | group_ref | keep_mark |
-                          multi_codepoint_char_type | [0-9cCM];
 
   # EOF error, used where it can be detected
   action premature_end_error {
@@ -249,16 +257,16 @@
   # set escapes scanner
   # --------------------------------------------------------------------------
   set_escape_sequence := |*
-    non_set_escape > (escaped_set_alpha, 2) {
-      emit(:escape, :literal, copy(data, ts-1, te))
-      fret;
-    };
-
-    any > (escaped_set_alpha, 1) {
+    set_escape > (escaped_set_alpha, 2) {
       fhold;
       fnext character_set;
       fcall escape_sequence;
     };
+
+    any > (escaped_set_alpha, 1) {
+      emit(:escape, :literal, copy(data, ts-1, te))
+      fret;
+    };
   *|;
 
 
@@ -538,67 +546,35 @@
 
     # Group backreference, named and numbered
     # ------------------------------------------------------------------------
-    backslash . (group_name_ref | group_number_ref) > (backslashed, 4) {
+    backslash . (group_name_backref | group_number_backref) > (backslashed, 4) {
       case text = copy(data, ts, te)
-      when /^\\([gk])(<>|'')/ # angle brackets
-        validation_error(:backref, 'ref/call', 'ref ID is empty')
-
-      # TODO: finer quirks of choosing recursive or non-recursive refs/calls.
-      # e.g.: `a-1` is a valid group id: 'aa'[/(?<a-1>a)\g<a-1>/] # => 'aa'
-      when /^\\([gk])<[^\p{digit}+\->][^>+\-]*>/ # angle-brackets
-        if $1 == 'k'
-          emit(:backref, :name_ref_ab, text)
-        else
-          emit(:backref, :name_call_ab, text)
-        end
-
-      when /^\\([gk])'[^\p{digit}+\-'][^'+\-]*'/ # single quotes
-        if $1 == 'k'
-          emit(:backref, :name_ref_sq, text)
-        else
-          emit(:backref, :name_call_sq, text)
-        end
-
-      when /^\\([gk])<\d+>/ # angle-brackets
-        if $1 == 'k'
-          emit(:backref, :number_ref_ab, text)
-        else
-          emit(:backref, :number_call_ab, text)
-        end
-
-      when /^\\([gk])'\d+'/ # single quotes
-        if $1 == 'k'
-          emit(:backref, :number_ref_sq, text)
-        else
-          emit(:backref, :number_call_sq, text)
-        end
-
-      when /^\\(?:g<\+|g<-|(k)<-)\d+>/ # angle-brackets
-        if $1 == 'k'
-          emit(:backref, :number_rel_ref_ab, text)
-        else
-          emit(:backref, :number_rel_call_ab, text)
-        end
-
-      when /^\\(?:g'\+|g'-|(k)'-)\d+'/ # single quotes
-        if $1 == 'k'
-          emit(:backref, :number_rel_ref_sq, text)
-        else
-          emit(:backref, :number_rel_call_sq, text)
-        end
-
-      when /^\\k<[^\p{digit}+\->][^>]*[+\-]\d+>/ # angle-brackets
-        emit(:backref, :name_recursion_ref_ab, text)
-
-      when /^\\k'[^\p{digit}+\-'][^']*[+\-]\d+'/ # single-quotes
-        emit(:backref, :name_recursion_ref_sq, text)
-
-      when /^\\([gk])<[+\-]?\d+[+\-]\d+>/ # angle-brackets
-        emit(:backref, :number_recursion_ref_ab, text)
-
-      when /^\\([gk])'[+\-]?\d+[+\-]\d+'/ # single-quotes
-        emit(:backref, :number_recursion_ref_sq, text)
+      when /^\\k(<>|'')/
+        validation_error(:backref, 'backreference', 'ref ID is empty')
+      when /^\\k(.)[^\p{digit}\-][^+\-]*\D$/
+        emit(:backref, $1 == '<' ? :name_ref_ab : :name_ref_sq, text)
+      when /^\\k(.)\d+\D$/
+        emit(:backref, $1 == '<' ? :number_ref_ab : :number_ref_sq, text)
+      when /^\\k(.)-\d+\D$/
+        emit(:backref, $1 == '<' ? :number_rel_ref_ab : :number_rel_ref_sq, text)
+      when /^\\k(.)[^\p{digit}\-].*[+\-]\d+\D$/
+        emit(:backref, $1 == '<' ? :name_recursion_ref_ab : :name_recursion_ref_sq, text)
+      when /^\\k(.)-?\d+[+\-]\d+\D$/
+        emit(:backref, $1 == '<' ? :number_recursion_ref_ab : :number_recursion_ref_sq, text)
+      end
+    };
 
+    # Group call, named and numbered
+    # ------------------------------------------------------------------------
+    backslash . (group_name_call | group_number_call) > (backslashed, 4) {
+      case text = copy(data, ts, te)
+      when /^\\g(<>|'')/
+        validation_error(:backref, 'subexpression call', 'ref ID is empty')
+      when /^\\g(.)[^\p{digit}+\->][^+\-]*/
+        emit(:backref, $1 == '<' ? :name_call_ab : :name_call_sq, text)
+      when /^\\g(.)\d+\D$/
+        emit(:backref, $1 == '<' ? :number_call_ab : :number_call_sq, text)
+      when /^\\g(.)[+-]\d+/
+        emit(:backref, $1 == '<' ? :number_rel_call_ab : :number_rel_call_sq, text)
       end
     };
 
@@ -677,10 +653,10 @@
 
 class Regexp::Scanner
   # General scanner error (catch all)
-  class ScannerError < StandardError; end
+  class ScannerError < Regexp::Parser::Error; end
 
   # Base for all scanner validation errors
-  class ValidationError < StandardError
+  class ValidationError < Regexp::Parser::Error
     def initialize(reason)
       super reason
     end
@@ -782,7 +758,7 @@ class Regexp::Scanner
 
   # lazy-load property maps when first needed
   require 'yaml'
-  PROP_MAPS_DIR = File.expand_path('../scanner/properties', __FILE__)
+  PROP_MAPS_DIR = File.join(__dir__, 'scanner', 'properties')
 
   def self.short_prop_map
     @short_prop_map ||= YAML.load_file("#{PROP_MAPS_DIR}/short.yml")

data/lib/regexp_parser/syntax.rb

@@ -1,9 +1,9 @@
 module Regexp::Syntax
-  class SyntaxError < StandardError; end
+  class SyntaxError < Regexp::Parser::Error; end
 end
 
-require File.expand_path('../syntax/tokens', __FILE__)
-require File.expand_path('../syntax/base', __FILE__)
-require File.expand_path('../syntax/any', __FILE__)
-require File.expand_path('../syntax/version_lookup', __FILE__)
-require File.expand_path('../syntax/versions', __FILE__)
+require_relative 'syntax/tokens'
+require_relative 'syntax/base'
+require_relative 'syntax/any'
+require_relative 'syntax/version_lookup'
+require_relative 'syntax/versions'

data/lib/regexp_parser/syntax/any.rb

@@ -4,7 +4,7 @@ module Regexp::Syntax
   # is useful during development, testing, and should be useful for some types
   # of transformations as well.
   class Any < Base
-    def initialize
+    def initialize # rubocop:disable Lint/MissingSuper
       @implements = { :* => [:*] }
     end
 

data/lib/regexp_parser/syntax/versions.rb

@@ -3,4 +3,4 @@
 #
 # Aliases for the latest patch version are provided as 'ruby/n.n',
 # e.g. 'ruby/1.9' refers to Ruby v1.9.3.
-Dir[File.expand_path('../versions/*.rb', __FILE__)].sort.each { |f| require f }
+Dir[File.join(__dir__, 'versions', '*.rb')].sort.each { |f| require f }

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '2.0.3'
+    VERSION = '2.1.0'
   end
 end

data/spec/expression/clone_spec.rb

@@ -27,8 +27,8 @@ RSpec.describe('Expression#clone') do
     expect(root_2.quantifier.object_id).not_to eq copy_2.quantifier.object_id
 
     # regression test
-    expect { root_2.clone }.not_to change { root_2.quantifier.object_id }
-    expect { root_2.clone }.not_to change { root_2.quantifier.text.object_id }
+    expect { root_2.clone }.not_to(change { root_2.quantifier.object_id })
+    expect { root_2.clone }.not_to(change { root_2.quantifier.text.object_id })
   end
 
   specify('Subexpression#clone') do
@@ -48,7 +48,7 @@ RSpec.describe('Expression#clone') do
     end
 
     # regression test
-    expect { root.clone }.not_to change { root.expressions.object_id }
+    expect { root.clone }.not_to(change { root.expressions.object_id })
   end
 
   specify('Group::Named#clone') do
@@ -69,7 +69,39 @@ RSpec.describe('Expression#clone') do
     end
 
     # regression test
-    expect { root_1.clone }.not_to change { root_1.name.object_id }
+    expect { root_1.clone }.not_to(change { root_1.name.object_id })
+  end
+
+  specify('Group::Options#clone') do
+    root = RP.parse('foo(?i)bar')
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.option_changes).to eq copy_1.option_changes
+    expect(root_1.option_changes.object_id).not_to eq copy_1.option_changes.object_id
+
+    # regression test
+    expect { root_1.clone }.not_to(change { root_1.option_changes.object_id })
+  end
+
+  specify('Backreference::Base#clone') do
+    root = RP.parse('(foo)\1')
+    copy = root.clone
+
+    expect(copy.to_s).to eq root.to_s
+
+    root_1 = root[1]
+    copy_1 = copy[1]
+
+    expect(root_1.referenced_expression.to_s).to eq copy_1.referenced_expression.to_s
+    expect(root_1.referenced_expression.object_id).not_to eq copy_1.referenced_expression.object_id
+
+    # regression test
+    expect { root_1.clone }.not_to(change { root_1.referenced_expression.object_id })
   end
 
   specify('Sequence#clone') do

data/spec/expression/free_space_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe(Regexp::Expression::FreeSpace) do
     space = root[0]
 
     expect(space).to be_instance_of(FreeSpace::WhiteSpace)
-    expect { space.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+    expect { space.quantify(:dummy, '#') }.to raise_error(Regexp::Parser::Error)
   end
 
   specify('comment quantify raises error') do
@@ -22,6 +22,6 @@ RSpec.describe(Regexp::Expression::FreeSpace) do
     comment = root[3]
 
     expect(comment).to be_instance_of(FreeSpace::Comment)
-    expect { comment.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+    expect { comment.quantify(:dummy, '#') }.to raise_error(Regexp::Parser::Error)
   end
 end

data/spec/expression/methods/match_length_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-RSpec.describe(Regexp::MatchLength) do
-  ML = described_class
+ML = Regexp::MatchLength
 
+RSpec.describe(Regexp::MatchLength) do
   specify('literal') { expect(ML.of(/a/).minmax).to eq [1, 1] }
   specify('literal sequence') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
   specify('dot') { expect(ML.of(/./).minmax).to eq [1, 1] }

data/spec/lexer/refcalls_spec.rb

@@ -32,6 +32,11 @@ RSpec.describe('RefCall lexing') do
   include_examples 'lex', "(abc)\\g'1'",
     3 => [:backref, :number_call,           "\\g'1'",     5, 10, 0, 0, 0]
 
+  include_examples 'lex', '\g<0>',
+    0 => [:backref, :number_call,           '\g<0>',      0,  5, 0, 0, 0]
+  include_examples 'lex', "\\g'0'",
+    0 => [:backref, :number_call,           "\\g'0'",     0,  5, 0, 0, 0]
+
   include_examples 'lex', '(abc)\g<-1>',
     3 => [:backref, :number_rel_call,       '\g<-1>',     5, 11, 0, 0, 0]
   include_examples 'lex', "(abc)\\g'-1'",

data/spec/parser/all_spec.rb

@@ -34,10 +34,10 @@ RSpec.describe(Regexp::Parser) do
   end
 
   specify('parse no quantifier target raises error') do
-    expect { RP.parse('?abc') }.to raise_error(ArgumentError)
+    expect { RP.parse('?abc') }.to raise_error(Regexp::Parser::Error)
   end
 
   specify('parse sequence no quantifier target raises error') do
-    expect { RP.parse('abc|?def') }.to raise_error(ArgumentError)
+    expect { RP.parse('abc|?def') }.to raise_error(Regexp::Parser::Error)
   end
 end

data/spec/parser/refcalls_spec.rb

@@ -29,6 +29,11 @@ RSpec.describe('Refcall parsing') do
   include_examples 'parse', /(abc)\g'1'/,
     1 => [:backref, :number_call, Backreference::NumberCall, number: 1]
 
+  include_examples 'parse', '\g<0>',
+    0 => [:backref, :number_call, Backreference::NumberCall, number: 0]
+  include_examples 'parse', "\\g'0'",
+    0 => [:backref, :number_call, Backreference::NumberCall, number: 0]
+
   include_examples 'parse', /(abc)\g<-1>/,
     1 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: -1]
   include_examples 'parse', /(abc)\g'-1'/,

data/spec/scanner/escapes_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe('Escape scanning') do
   include_examples 'scan', /c\at/,            1 => [:escape,  :bell,             '\a',             1,  3]
 
   # not an escape outside a character set
-  include_examples 'scan', /c\bt/,            1 => [:anchor,  :word_boundary,    '\b',             1, 3]
+  include_examples 'scan', /c\bt/,            1 => [:anchor,  :word_boundary,    '\b',             1,  3]
 
   include_examples 'scan', /c\ft/,            1 => [:escape,  :form_feed,        '\f',             1,  3]
   include_examples 'scan', /c\nt/,            1 => [:escape,  :newline,          '\n',             1,  3]

data/spec/scanner/refcalls_spec.rb

@@ -5,9 +5,19 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(abc)\1' ,          3 => [:backref, :number,                  '\1',         5, 7]
 
   # Group back-references, named, numbered, and relative
+  #
+  # NOTE: only \g supports forward-looking references using '+', e.g. \g<+1>
+  # refers to the next group, but \k<+1> refers to a group named '+1'.
+  # Inversely, only \k supports addition or substraction of a recursion level.
+  # E.g. \k<x+0> refers to a group named 'x' at the current recursion level,
+  # but \g<x+0> refers to a a group named 'x+0'.
+  #
   include_examples 'scan', '(?<X>abc)\k<X>',    3 => [:backref, :name_ref_ab,             '\k<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\k'X'",   3 => [:backref, :name_ref_sq,             "\\k'X'",     9, 14]
 
+  include_examples 'scan', '(?<+1>abc)\k<+1>',  3 => [:backref, :name_ref_ab,             '\k<+1>',    10, 16]
+  include_examples 'scan', "(?<+1>abc)\\k'+1'", 3 => [:backref, :name_ref_sq,             "\\k'+1'",   10, 16]
+
   include_examples 'scan', '(abc)\k<1>',        3 => [:backref, :number_ref_ab,           '\k<1>',      5, 10]
   include_examples 'scan', "(abc)\\k'1'",       3 => [:backref, :number_ref_sq,           "\\k'1'",     5, 10]
 
@@ -18,9 +28,15 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(?<X>abc)\g<X>',    3 => [:backref, :name_call_ab,            '\g<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\g'X'",   3 => [:backref, :name_call_sq,            "\\g'X'",     9, 14]
 
+  include_examples 'scan', '(?<X>abc)\g<X-1>',  3 => [:backref, :name_call_ab,            '\g<X-1>',    9, 16]
+  include_examples 'scan', "(?<X>abc)\\g'X-1'", 3 => [:backref, :name_call_sq,            "\\g'X-1'",   9, 16]
+
   include_examples 'scan', '(abc)\g<1>',        3 => [:backref, :number_call_ab,          '\g<1>',      5, 10]
   include_examples 'scan', "(abc)\\g'1'",       3 => [:backref, :number_call_sq,          "\\g'1'",     5, 10]
 
+  include_examples 'scan', 'a(b|\g<0>)',        4 => [:backref, :number_call_ab,          '\g<0>',      4, 9]
+  include_examples 'scan', "a(b|\\g'0')",       4 => [:backref, :number_call_sq,          "\\g'0'",     4, 9]
+
   include_examples 'scan', '(abc)\g<-1>',       3 => [:backref, :number_rel_call_ab,      '\g<-1>',     5, 11]
   include_examples 'scan', "(abc)\\g'-1'",      3 => [:backref, :number_rel_call_sq,      "\\g'-1'",    5, 11]
 
@@ -33,4 +49,7 @@ RSpec.describe('RefCall scanning') do
 
   include_examples 'scan', '(abc)\k<1-0>',      3 => [:backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12]
   include_examples 'scan', "(abc)\\k'1-0'",     3 => [:backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12]
+
+  include_examples 'scan', '(abc)\k<+1-0>',     3 => [:backref, :name_recursion_ref_ab,   '\k<+1-0>',   5, 13]
+  include_examples 'scan', "(abc)\\k'+1-0'",    3 => [:backref, :name_recursion_ref_sq,   "\\k'+1-0'",  5, 13]
 end

data/spec/scanner/sets_spec.rb

@@ -6,8 +6,18 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[^n]/,                  1 => [:set,    :negate,          '^',          1, 2]
 
   include_examples 'scan', /[c]/,                   1 => [:literal, :literal,        'c',          1, 2]
-  include_examples 'scan', /[\b]/,                  1 => [:escape,  :backspace,      '\b',         1, 3]
-  include_examples 'scan', /[A\bX]/,                2 => [:escape,  :backspace,      '\b',         2, 4]
+  include_examples 'scan', /[^d]/,                  2 => [:literal, :literal,        'd',          2, 3]
+
+  include_examples 'scan', /[\b]/,                  1 => [:escape, :backspace,       '\b',         1, 3]
+  include_examples 'scan', /[A\bX]/,                2 => [:escape, :backspace,       '\b',         2, 4]
+
+  include_examples 'scan', /[\a]/,                  1 => [:escape, :bell,            '\a',         1, 3]
+  include_examples 'scan', /[\e]/,                  1 => [:escape, :escape,          '\e',         1, 3]
+  include_examples 'scan', /[\f]/,                  1 => [:escape, :form_feed,       '\f',         1, 3]
+  include_examples 'scan', /[\n]/,                  1 => [:escape, :newline,         '\n',         1, 3]
+  include_examples 'scan', /[\r]/,                  1 => [:escape, :carriage,        '\r',         1, 3]
+  include_examples 'scan', /[\t]/,                  1 => [:escape, :tab,             '\t',         1, 3]
+  include_examples 'scan', /[\v]/,                  1 => [:escape, :vertical_tab,    '\v',         1, 3]
 
   include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
   include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
@@ -18,22 +28,36 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
   include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
 
-  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
-
-  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
+  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
+  include_examples 'scan', '[\u0040]',              1 => [:escape, :codepoint,       '\u0040',     1, 7]
+  include_examples 'scan', '[\u{40}]',              1 => [:escape, :codepoint_list,  '\u{40}',     1, 7]
+  include_examples 'scan', '[\c2]',                 1 => [:escape, :control,         '\c2',        1, 4]
+  include_examples 'scan', '[\C-C]',                1 => [:escape, :control,         '\C-C',       1, 5]
+  include_examples 'scan', '[\x20]',                1 => [:escape, :hex,             '\x20',       1, 5]
+  include_examples 'scan', '[\M-Z]',                1 => [:escape, :meta_sequence,   '\M-Z',       1, 5]
+  include_examples 'scan', '[\M-\C-X]',             1 => [:escape, :meta_sequence,   '\M-\C-X',    1, 8]
+  include_examples 'scan', '[\\[]',                 1 => [:escape, :set_open,        '\[',         1, 3]
+  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
+  include_examples 'scan', '[a\-]',                 2 => [:escape, :literal,         '\-',         2, 4]
+  include_examples 'scan', '[\-c]',                 1 => [:escape, :literal,         '\-',         1, 3]
+  include_examples 'scan', '[\.]',                  1 => [:escape, :literal,         '\.',         1, 3]
+  include_examples 'scan', '[\?]',                  1 => [:escape, :literal,         '\?',         1, 3]
+  include_examples 'scan', '[\*]',                  1 => [:escape, :literal,         '\*',         1, 3]
+  include_examples 'scan', '[\+]',                  1 => [:escape, :literal,         '\+',         1, 3]
+  include_examples 'scan', '[\|]',                  1 => [:escape, :literal,         '\|',         1, 3]
+  include_examples 'scan', '[\{]',                  1 => [:escape, :literal,         '\{',         1, 3]
+  include_examples 'scan', '[\}]',                  1 => [:escape, :literal,         '\}',         1, 3]
+  include_examples 'scan', '[\(]',                  1 => [:escape, :literal,         '\(',         1, 3]
+  include_examples 'scan', '[\)]',                  1 => [:escape, :literal,         '\)',         1, 3]
   include_examples 'scan', '[\!]',                  1 => [:escape, :literal,         '\!',         1, 3]
   include_examples 'scan', '[\#]',                  1 => [:escape, :literal,         '\#',         1, 3]
-  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
-  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
   include_examples 'scan', '[\A]',                  1 => [:escape, :literal,         '\A',         1, 3]
   include_examples 'scan', '[\z]',                  1 => [:escape, :literal,         '\z',         1, 3]
   include_examples 'scan', '[\g]',                  1 => [:escape, :literal,         '\g',         1, 3]
   include_examples 'scan', '[\K]',                  1 => [:escape, :literal,         '\K',         1, 3]
   include_examples 'scan', '[\R]',                  1 => [:escape, :literal,         '\R',         1, 3]
   include_examples 'scan', '[\X]',                  1 => [:escape, :literal,         '\X',         1, 3]
-  include_examples 'scan', '[\c2]',                 1 => [:escape, :literal,         '\c',         1, 3]
   include_examples 'scan', '[\B]',                  1 => [:escape, :literal,         '\B',         1, 3]
-  include_examples 'scan', '[a\-c]',                2 => [:escape, :literal,         '\-',         2, 4]
 
   include_examples 'scan', /[\d]/,                  1 => [:type,   :digit,           '\d',         1, 3]
   include_examples 'scan', /[\da-z]/,               1 => [:type,   :digit,           '\d',         1, 3]
@@ -54,8 +78,14 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[a-b-]/,                4 => [:literal, :literal,        '-',          4, 5]
   include_examples 'scan', /[-a]/,                  1 => [:literal, :literal,        '-',          1, 2]
   include_examples 'scan', /[a-c^]/,                4 => [:literal, :literal,        '^',          4, 5]
-  include_examples 'scan', /[a-bd-f]/,              2 => [:set,    :range,           '-',          2, 3]
-  include_examples 'scan', /[a-cd-f]/,              5 => [:set,    :range,           '-',          5, 6]
+  include_examples 'scan', /[a-bd-f]/,              2 => [:set,     :range,          '-',          2, 3]
+  include_examples 'scan', /[a-cd-f]/,              5 => [:set,     :range,          '-',          5, 6]
+  # this is a buggy range, it matches only `c`, but not `a`, `b` or `-`
+  include_examples 'scan', /[a-[c]]/,               2 => [:set,     :range,          '-',          2, 3]
+  # these are not ranges, they match `a`, `c` and `-` (or non-`-` if negated)
+  include_examples 'scan', /[[a]-[c]]/,             4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[[a]-c]/,               4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[^-c]/,                 2 => [:literal, :literal,        '-',          2, 3]
 
   include_examples 'scan', /[a[:digit:]c]/,         2 => [:posixclass,    :digit,    '[:digit:]',  2, 11]
   include_examples 'scan', /[[:digit:][:space:]]/,  2 => [:posixclass,    :space,    '[:space:]', 10, 19]
@@ -64,6 +94,7 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[a-d&&g-h]/,            4 => [:set,    :intersection,    '&&',         4, 6]
   include_examples 'scan', /[a&&]/,                 2 => [:set,    :intersection,    '&&',         2, 4]
   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]