activerecord-ejection_seat 0.3.0 → 0.3.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (25) hide show
  1. checksums.yaml +4 -4
  2. data/.ruby-version +1 -1
  3. data/.tool-versions +1 -1
  4. data/CODE_OF_CONDUCT.md +1 -1
  5. data/Gemfile.lock +30 -30
  6. data/README.md +19 -8
  7. data/activerecord-ejection_seat.gemspec +3 -3
  8. data/lib/activerecord-ejection_seat/version.rb +1 -1
  9. data/sorbet/rbi/gems/{activemodel@7.0.4.1.rbi → activemodel@7.0.4.2.rbi} +0 -0
  10. data/sorbet/rbi/gems/{activerecord@7.0.4.1.rbi → activerecord@7.0.4.2.rbi} +128 -128
  11. data/sorbet/rbi/gems/{activesupport@7.0.4.1.rbi → activesupport@7.0.4.2.rbi} +1 -1
  12. data/sorbet/rbi/gems/{concurrent-ruby@1.1.10.rbi → concurrent-ruby@1.2.0.rbi} +1158 -1220
  13. data/sorbet/rbi/gems/irb@1.6.2.rbi +35 -50
  14. data/sorbet/rbi/gems/{language_server-protocol@3.17.0.2.rbi → language_server-protocol@3.17.0.3.rbi} +0 -0
  15. data/sorbet/rbi/gems/{parser@3.2.0.0.rbi → parser@3.2.1.0.rbi} +596 -307
  16. data/sorbet/rbi/gems/{regexp_parser@2.6.1.rbi → regexp_parser@2.7.0.rbi} +598 -144
  17. data/sorbet/rbi/gems/{rubocop-ast@1.24.1.rbi → rubocop-ast@1.26.0.rbi} +94 -94
  18. data/sorbet/rbi/gems/{rubocop-minitest@0.26.1.rbi → rubocop-minitest@0.27.0.rbi} +111 -45
  19. data/sorbet/rbi/gems/{rubocop-sorbet@0.6.11.rbi → rubocop-sorbet@0.7.0.rbi} +158 -114
  20. data/sorbet/rbi/gems/{rubocop@1.43.0.rbi → rubocop@1.45.1.rbi} +1339 -954
  21. data/sorbet/rbi/gems/{ruby-lsp@0.3.8.rbi → ruby-lsp@0.4.0.rbi} +0 -0
  22. data/sorbet/rbi/gems/{syntax_tree@5.2.0.rbi → syntax_tree@6.0.0.rbi} +0 -0
  23. data/sorbet/rbi/gems/tzinfo@2.0.6.rbi +5917 -0
  24. metadata +22 -22
  25. data/sorbet/rbi/gems/tzinfo@2.0.5.rbi +0 -8
data/sorbet/rbi/gems/{regexp_parser@2.6.1.rbi → regexp_parser@2.7.0.rbi} RENAMED
@@ -4,8 +4,10 @@
4
4
  # This is an autogenerated file for types exported from the `regexp_parser` gem.
5
5
  # Please instead update this file by running `bin/tapioca gem regexp_parser`.
6
6
 
7
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#1
7
8
  module Regexp::Expression; end
8
9
 
10
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5
9
11
  class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
10
12
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
11
13
  def alternatives; end
@@ -13,7 +15,7 @@ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
13
15
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
14
16
  def human_name; end
15
17
 
16
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#127
18
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
17
19
  def match_length; end
18
20
  end
19
21
 
@@ -21,11 +23,14 @@ end
21
23
  Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
22
24
 
23
25
  # A sequence of expressions, used by Alternation as one of its alternative.
26
+ #
27
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3
24
28
  class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
25
29
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10
26
30
  def human_name; end
27
31
  end
28
32
 
33
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2
29
34
  module Regexp::Expression::Anchor; end
30
35
 
31
36
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18
@@ -34,16 +39,19 @@ Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
34
39
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20
35
40
  Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
36
41
 
42
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
37
43
  class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
38
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
44
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
39
45
  def match_length; end
40
46
  end
41
47
 
48
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5
42
49
  class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
43
50
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11
44
51
  def human_name; end
45
52
  end
46
53
 
54
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8
47
55
  class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
48
56
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12
49
57
  def human_name; end
@@ -58,68 +66,83 @@ Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
58
66
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22
59
67
  Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
60
68
 
69
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6
61
70
  class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
62
71
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13
63
72
  def human_name; end
64
73
  end
65
74
 
75
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9
66
76
  class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
67
77
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14
68
78
  def human_name; end
69
79
  end
70
80
 
81
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11
71
82
  class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
72
83
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15
73
84
  def human_name; end
74
85
  end
75
86
 
87
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16
76
88
  class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
77
89
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16
78
90
  def human_name; end
79
91
  end
80
92
 
93
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14
81
94
  class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
82
95
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17
83
96
  def human_name; end
84
97
  end
85
98
 
99
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13
86
100
  class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
87
101
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18
88
102
  def human_name; end
89
103
  end
90
104
 
105
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#86
91
106
  module Regexp::Expression::Assertion; end
92
107
 
108
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#87
93
109
  class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
94
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
110
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
95
111
  def match_length; end
96
112
  end
97
113
 
114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#89
98
115
  class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
99
116
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19
100
117
  def human_name; end
101
118
  end
102
119
 
120
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#92
103
121
  class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
104
122
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20
105
123
  def human_name; end
106
124
  end
107
125
 
126
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#90
108
127
  class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
109
128
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21
110
129
  def human_name; end
111
130
  end
112
131
 
132
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#93
113
133
  class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
114
134
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22
115
135
  def human_name; end
116
136
  end
117
137
 
118
138
  # TODO: unify name with token :backref, one way or the other, in v3.0.0
139
+ #
140
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3
119
141
  module Regexp::Expression::Backreference; end
120
142
 
143
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
121
144
  class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
122
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#151
145
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155
123
146
  def match_length; end
124
147
 
125
148
  # Returns the value of attribute referenced_expression.
@@ -134,16 +157,22 @@ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
134
157
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5
135
158
  def referenced_expression=(_arg0); end
136
159
 
160
+ # @return [Boolean]
161
+ #
162
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
163
+ def referential?; end
164
+
137
165
  private
138
166
 
139
167
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#7
140
168
  def initialize_copy(orig); end
141
169
  end
142
170
 
171
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#39
143
172
  class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
144
173
  # @return [Name] a new instance of Name
145
174
  #
146
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#27
175
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
147
176
  def initialize(token, options = T.unsafe(nil)); end
148
177
 
149
178
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
@@ -151,36 +180,39 @@ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backrefere
151
180
 
152
181
  # Returns the value of attribute name.
153
182
  #
154
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
183
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
155
184
  def name; end
156
185
 
157
186
  # Returns the value of attribute name.
158
187
  #
159
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
188
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
160
189
  def reference; end
161
190
  end
162
191
 
192
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#55
163
193
  class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
164
194
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
165
195
  def human_name; end
166
196
  end
167
197
 
198
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#67
168
199
  class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
169
200
  # @return [NameRecursionLevel] a new instance of NameRecursionLevel
170
201
  #
171
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
202
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#70
172
203
  def initialize(token, options = T.unsafe(nil)); end
173
204
 
174
205
  # Returns the value of attribute recursion_level.
175
206
  #
176
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#52
207
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#68
177
208
  def recursion_level; end
178
209
  end
179
210
 
211
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#29
180
212
  class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
181
213
  # @return [Number] a new instance of Number
182
214
  #
183
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#17
215
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#33
184
216
  def initialize(token, options = T.unsafe(nil)); end
185
217
 
186
218
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
@@ -188,48 +220,52 @@ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backrefe
188
220
 
189
221
  # Returns the value of attribute number.
190
222
  #
191
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
223
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
192
224
  def number; end
193
225
 
194
226
  # Returns the value of attribute number.
195
227
  #
196
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
228
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
197
229
  def reference; end
198
230
  end
199
231
 
232
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
200
233
  class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
201
234
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
202
235
  def human_name; end
203
236
  end
204
237
 
238
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56
205
239
  class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
206
240
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
207
241
  def human_name; end
208
242
  end
209
243
 
244
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#58
210
245
  class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
211
246
  # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
212
247
  #
213
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
248
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#61
214
249
  def initialize(token, options = T.unsafe(nil)); end
215
250
 
216
251
  # Returns the value of attribute recursion_level.
217
252
  #
218
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
253
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#59
219
254
  def recursion_level; end
220
255
  end
221
256
 
257
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49
222
258
  class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
223
259
  # Returns the value of attribute effective_number.
224
260
  #
225
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
261
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
226
262
  def effective_number; end
227
263
 
228
264
  # Sets the attribute effective_number
229
265
  #
230
266
  # @param value the value to set the attribute effective_number to.
231
267
  #
232
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
268
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
233
269
  def effective_number=(_arg0); end
234
270
 
235
271
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
@@ -237,13 +273,13 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
237
273
 
238
274
  # Returns the value of attribute effective_number.
239
275
  #
240
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
276
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
241
277
  def reference; end
242
278
  end
243
279
 
280
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#2
244
281
  class Regexp::Expression::Base
245
282
  include ::Regexp::Expression::Shared
246
- include ::RuboCop::Ext::RegexpParser::Expression::Base
247
283
  extend ::Regexp::Expression::Shared::ClassMethods
248
284
 
249
285
  # @return [Base] a new instance of Base
@@ -518,9 +554,8 @@ class Regexp::Expression::Base
518
554
  def initialize_copy(orig); end
519
555
  end
520
556
 
557
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2
521
558
  class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
522
- include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
523
-
524
559
  # @return [CharacterSet] a new instance of CharacterSet
525
560
  #
526
561
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#9
@@ -546,7 +581,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
546
581
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
547
582
  def closed?; end
548
583
 
549
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
584
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
550
585
  def match_length; end
551
586
 
552
587
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#15
@@ -578,25 +613,28 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
578
613
  def parts; end
579
614
  end
580
615
 
616
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3
581
617
  class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
582
618
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
583
619
  def human_name; end
584
620
 
585
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
621
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
586
622
  def match_length; end
587
623
  end
588
624
 
625
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5
589
626
  class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
590
627
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
591
628
  def human_name; end
592
629
 
593
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
630
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
594
631
  def match_length; end
595
632
  end
596
633
 
597
634
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6
598
635
  Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
599
636
 
637
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3
600
638
  class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
601
639
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#9
602
640
  def <<(exp); end
@@ -609,7 +647,7 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
609
647
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
610
648
  def human_name; end
611
649
 
612
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
650
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
613
651
  def match_length; end
614
652
 
615
653
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#19
@@ -622,46 +660,72 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
622
660
  def ts; end
623
661
  end
624
662
 
663
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2
625
664
  module Regexp::Expression::CharacterType; end
626
665
 
666
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5
627
667
  class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
628
668
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32
629
669
  def human_name; end
630
670
  end
631
671
 
672
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
632
673
  class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
633
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
674
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
634
675
  def match_length; end
635
676
  end
636
677
 
678
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6
637
679
  class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
680
+
681
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15
638
682
  class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
683
+
684
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8
639
685
  class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
686
+
687
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14
640
688
  class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
689
+
690
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7
641
691
  class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
692
+
693
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9
642
694
  class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
695
+
696
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13
643
697
  class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
698
+
699
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11
644
700
  class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
701
+
702
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12
645
703
  class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
704
+
705
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10
646
706
  class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
647
707
 
708
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8
648
709
  class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
649
710
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33
650
711
  def human_name; end
651
712
  end
652
713
 
714
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
653
715
  module Regexp::Expression::Conditional; end
654
716
 
717
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#29
655
718
  class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
656
719
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
657
720
  def human_name; end
658
721
  end
659
722
 
723
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#9
660
724
  class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
661
725
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
662
726
  def human_name; end
663
727
 
664
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
728
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
665
729
  def match_length; end
666
730
 
667
731
  # Name or number of the referenced capturing group that determines state.
@@ -682,65 +746,77 @@ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
682
746
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
683
747
  def referenced_expression=(_arg0); end
684
748
 
749
+ # @return [Boolean]
750
+ #
751
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#24
752
+ def referential?; end
753
+
685
754
  private
686
755
 
687
756
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19
688
757
  def initialize_copy(orig); end
689
758
  end
690
759
 
760
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#31
691
761
  class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
692
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30
762
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
693
763
  def <<(exp); end
694
764
 
695
765
  # @raise [TooManyBranches]
696
766
  #
697
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
767
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
698
768
  def add_sequence(active_opts = T.unsafe(nil)); end
699
769
 
700
770
  # @raise [TooManyBranches]
701
771
  #
702
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
772
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
703
773
  def branch(active_opts = T.unsafe(nil)); end
704
774
 
705
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
775
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
706
776
  def branches; end
707
777
 
708
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46
778
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
709
779
  def condition; end
710
780
 
711
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
781
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#45
712
782
  def condition=(exp); end
713
783
 
714
784
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
715
785
  def human_name; end
716
786
 
717
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#127
787
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
718
788
  def match_length; end
719
789
 
720
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
790
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#66
721
791
  def parts; end
722
792
 
723
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
793
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
724
794
  def reference; end
725
795
 
726
796
  # Returns the value of attribute referenced_expression.
727
797
  #
728
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
798
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
729
799
  def referenced_expression; end
730
800
 
731
801
  # Sets the attribute referenced_expression
732
802
  #
733
803
  # @param value the value to set the attribute referenced_expression to.
734
804
  #
735
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
805
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
736
806
  def referenced_expression=(_arg0); end
737
807
 
808
+ # @return [Boolean]
809
+ #
810
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
811
+ def referential?; end
812
+
738
813
  private
739
814
 
740
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
815
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#70
741
816
  def initialize_copy(orig); end
742
817
  end
743
818
 
819
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3
744
820
  class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
745
821
  # @return [TooManyBranches] a new instance of TooManyBranches
746
822
  #
@@ -749,8 +825,11 @@ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
749
825
  end
750
826
 
751
827
  # TODO: unify naming with Token::Escape, one way or the other, in v3.0.0
828
+ #
829
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3
752
830
  module Regexp::Expression::EscapeSequence; end
753
831
 
832
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64
754
833
  class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
755
834
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#65
756
835
  def char; end
@@ -764,9 +843,13 @@ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp
764
843
  def meta_char_to_codepoint(meta_char); end
765
844
  end
766
845
 
846
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28
767
847
  class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
848
+
849
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29
768
850
  class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
769
851
 
852
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4
770
853
  class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
771
854
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#10
772
855
  def char; end
@@ -774,13 +857,17 @@ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
774
857
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#5
775
858
  def codepoint; end
776
859
 
777
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
860
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
778
861
  def match_length; end
779
862
  end
780
863
 
864
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30
781
865
  class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
866
+
867
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#38
782
868
  class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
783
869
 
870
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40
784
871
  class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
785
872
  # @raise [NoMethodError]
786
873
  #
@@ -798,46 +885,61 @@ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::
798
885
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#53
799
886
  def codepoints; end
800
887
 
801
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#160
888
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164
802
889
  def match_length; end
803
890
  end
804
891
 
892
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82
805
893
  class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
806
894
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#83
807
895
  def codepoint; end
808
896
  end
809
897
 
898
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31
810
899
  class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
900
+
901
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37
811
902
  class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
812
903
 
904
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22
813
905
  class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
814
906
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#23
815
907
  def char; end
816
908
  end
817
909
 
910
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88
818
911
  class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
819
912
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#89
820
913
  def codepoint; end
821
914
  end
822
915
 
916
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94
823
917
  class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
824
918
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#95
825
919
  def codepoint; end
826
920
  end
827
921
 
922
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32
828
923
  class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
829
924
 
925
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58
830
926
  class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
831
927
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#59
832
928
  def char; end
833
929
  end
834
930
 
931
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33
835
932
  class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
933
+
934
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34
836
935
  class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
936
+
937
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#35
837
938
  class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
838
939
 
940
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
839
941
  class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
840
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
942
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
841
943
  def match_length; end
842
944
 
843
945
  # @raise [Regexp::Parser::Error]
@@ -846,17 +948,22 @@ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
846
948
  def quantify(*_args); end
847
949
  end
848
950
 
951
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2
849
952
  module Regexp::Expression::Group; end
850
953
 
851
954
  # Special case. Absence group can match 0.. chars, irrespective of content.
852
955
  # TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})`
956
+ #
957
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#34
853
958
  class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
854
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#168
959
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172
855
960
  def match_length; end
856
961
  end
857
962
 
963
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#35
858
964
  class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
859
965
 
966
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3
860
967
  class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
861
968
  # @return [Boolean]
862
969
  #
@@ -872,6 +979,7 @@ class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
872
979
  def parts; end
873
980
  end
874
981
 
982
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#55
875
983
  class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
876
984
  # @return [Boolean]
877
985
  #
@@ -911,6 +1019,7 @@ class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
911
1019
  def number_at_level=(_arg0); end
912
1020
  end
913
1021
 
1022
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#77
914
1023
  class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
915
1024
  # @return [Boolean]
916
1025
  #
@@ -921,6 +1030,7 @@ class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
921
1030
  def parts; end
922
1031
  end
923
1032
 
1033
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#62
924
1034
  class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
925
1035
  # @return [Named] a new instance of Named
926
1036
  #
@@ -948,6 +1058,8 @@ end
948
1058
 
949
1059
  # TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
950
1060
  # longer inherit from Group because it is effectively a terminal expression.
1061
+ #
1062
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#38
951
1063
  class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
952
1064
  # Returns the value of attribute option_changes.
953
1065
  #
@@ -970,6 +1082,7 @@ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
970
1082
  def initialize_copy(orig); end
971
1083
  end
972
1084
 
1085
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#13
973
1086
  class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
974
1087
  # @return [Passive] a new instance of Passive
975
1088
  #
@@ -992,31 +1105,36 @@ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
992
1105
  def parts; end
993
1106
  end
994
1107
 
1108
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2
995
1109
  module Regexp::Expression::Keep; end
996
1110
 
997
1111
  # TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression
998
1112
  # that contains all expressions to its left.
1113
+ #
1114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5
999
1115
  class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
1000
1116
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
1001
1117
  def human_name; end
1002
1118
 
1003
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
1119
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
1004
1120
  def match_length; end
1005
1121
  end
1006
1122
 
1123
+ # source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2
1007
1124
  class Regexp::Expression::Literal < ::Regexp::Expression::Base
1008
1125
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
1009
1126
  def human_name; end
1010
1127
 
1011
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#101
1128
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105
1012
1129
  def match_length; end
1013
1130
  end
1014
1131
 
1015
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#81
1132
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85
1016
1133
  Regexp::Expression::MatchLength = Regexp::MatchLength
1017
1134
 
1135
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
1018
1136
  class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
1019
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
1137
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1020
1138
  def match_length; end
1021
1139
 
1022
1140
  # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#7
@@ -1032,6 +1150,8 @@ end
1032
1150
  # call super in #initialize, but raise in #quantifier= and #quantify,
1033
1151
  # or introduce an Expression::Quantifiable intermediate class.
1034
1152
  # Or actually allow chaining as a more concise but tricky solution than PR#69.
1153
+ #
1154
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6
1035
1155
  class Regexp::Expression::Quantifier
1036
1156
  include ::Regexp::Expression::Shared
1037
1157
  extend ::Regexp::Expression::Shared::ClassMethods
@@ -1143,6 +1263,7 @@ end
1143
1263
  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9
1144
1264
  Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
1145
1265
 
1266
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2
1146
1267
  class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
1147
1268
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41
1148
1269
  def human_name; end
@@ -1159,14 +1280,16 @@ end
1159
1280
  #
1160
1281
  # Used as the base class for the Alternation alternatives, Conditional
1161
1282
  # branches, and CharacterSet::Intersection intersected sequences.
1283
+ #
1284
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
1162
1285
  class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1163
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#28
1286
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
1164
1287
  def quantify(*args); end
1165
1288
 
1166
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1289
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1167
1290
  def starts_at; end
1168
1291
 
1169
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1292
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1170
1293
  def ts; end
1171
1294
 
1172
1295
  class << self
@@ -1176,6 +1299,8 @@ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1176
1299
  end
1177
1300
 
1178
1301
  # abstract class
1302
+ #
1303
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3
1179
1304
  class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
1180
1305
  # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#13
1181
1306
  def <<(exp); end
@@ -1202,6 +1327,7 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio
1202
1327
  def ts; end
1203
1328
  end
1204
1329
 
1330
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#2
1205
1331
  module Regexp::Expression::Shared
1206
1332
  mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
1207
1333
 
@@ -1257,7 +1383,7 @@ module Regexp::Expression::Shared
1257
1383
  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
1258
1384
  def is?(test_token, test_type = T.unsafe(nil)); end
1259
1385
 
1260
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1386
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#87
1261
1387
  def nesting_level=(lvl); end
1262
1388
 
1263
1389
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#71
@@ -1315,12 +1441,17 @@ module Regexp::Expression::Shared
1315
1441
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#63
1316
1442
  def quantified?; end
1317
1443
 
1318
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#89
1444
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#93
1319
1445
  def quantifier=(qtf); end
1320
1446
 
1321
1447
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#59
1322
1448
  def quantifier_affix(expression_format); end
1323
1449
 
1450
+ # @return [Boolean]
1451
+ #
1452
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1453
+ def referential?; end
1454
+
1324
1455
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#38
1325
1456
  def starts_at; end
1326
1457
 
@@ -1369,6 +1500,8 @@ module Regexp::Expression::Shared
1369
1500
  end
1370
1501
 
1371
1502
  # filled in ./methods/*.rb
1503
+ #
1504
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#3
1372
1505
  module Regexp::Expression::Shared::ClassMethods
1373
1506
  # Convenience method to init a valid Expression without a Regexp::Token
1374
1507
  #
@@ -1384,6 +1517,7 @@ module Regexp::Expression::Shared::ClassMethods
1384
1517
  def token_class; end
1385
1518
  end
1386
1519
 
1520
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2
1387
1521
  class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1388
1522
  include ::Enumerable
1389
1523
 
@@ -1395,25 +1529,25 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1395
1529
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#18
1396
1530
  def <<(exp); end
1397
1531
 
1398
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1532
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1399
1533
  def [](*args, &block); end
1400
1534
 
1401
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1535
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1402
1536
  def at(*args, &block); end
1403
1537
 
1404
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#35
1538
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#34
1405
1539
  def dig(*indices); end
1406
1540
 
1407
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1541
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1408
1542
  def each(*args, &block); end
1409
1543
 
1410
1544
  # Iterates over the expressions of this expression as an array, passing
1411
1545
  # the expression and its index within its parent to the given block.
1412
1546
  #
1413
1547
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#39
1414
- def each_expression(include_self = T.unsafe(nil)); end
1548
+ def each_expression(include_self = T.unsafe(nil), &block); end
1415
1549
 
1416
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1550
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1417
1551
  def empty?(*args, &block); end
1418
1552
 
1419
1553
  # Returns the value of attribute expressions.
@@ -1428,35 +1562,35 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1428
1562
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1429
1563
  def expressions=(_arg0); end
1430
1564
 
1431
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1565
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1432
1566
  def fetch(*args, &block); end
1433
1567
 
1434
1568
  # Returns a new array with the results of calling the given block once
1435
1569
  # for every expression. If a block is not given, returns an array with
1436
1570
  # each expression and its level index as an array.
1437
1571
  #
1438
- # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#50
1572
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#53
1439
1573
  def flat_map(include_self = T.unsafe(nil)); end
1440
1574
 
1441
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1575
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1442
1576
  def index(*args, &block); end
1443
1577
 
1444
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#114
1578
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118
1445
1579
  def inner_match_length; end
1446
1580
 
1447
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1581
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1448
1582
  def join(*args, &block); end
1449
1583
 
1450
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1584
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1451
1585
  def last(*args, &block); end
1452
1586
 
1453
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1587
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1454
1588
  def length(*args, &block); end
1455
1589
 
1456
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#107
1590
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111
1457
1591
  def match_length; end
1458
1592
 
1459
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#45
1593
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#44
1460
1594
  def parts; end
1461
1595
 
1462
1596
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
@@ -1465,10 +1599,15 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1465
1599
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1466
1600
  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1467
1601
 
1468
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#41
1602
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#40
1469
1603
  def te; end
1470
1604
 
1471
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#49
1605
+ # @return [Boolean]
1606
+ #
1607
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#55
1608
+ def terminal?; end
1609
+
1610
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#48
1472
1611
  def to_h; end
1473
1612
 
1474
1613
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1487,7 +1626,7 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1487
1626
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#16
1488
1627
  def traverse(include_self = T.unsafe(nil), &block); end
1489
1628
 
1490
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1629
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1491
1630
  def values_at(*args, &block); end
1492
1631
 
1493
1632
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1513,22 +1652,36 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1513
1652
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
1514
1653
  def initialize_copy(orig); end
1515
1654
 
1516
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#58
1655
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#61
1517
1656
  def intersperse(expressions, separator); end
1518
1657
  end
1519
1658
 
1520
1659
  # TODO: unify name with token :property, one way or the other, in v3.0.0
1660
+ #
1661
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3
1521
1662
  module Regexp::Expression::UnicodeProperty; end
1522
1663
 
1664
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113
1523
1665
  class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
1666
+
1667
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18
1524
1668
  class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
1669
+
1670
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19
1525
1671
  class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
1672
+
1673
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36
1526
1674
  class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
1675
+
1676
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20
1527
1677
  class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
1678
+
1679
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#37
1528
1680
  class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
1529
1681
 
1682
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
1530
1683
  class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1531
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
1684
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1532
1685
  def match_length; end
1533
1686
 
1534
1687
  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#9
@@ -1543,77 +1696,217 @@ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1543
1696
  def shortcut; end
1544
1697
  end
1545
1698
 
1699
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21
1546
1700
  class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
1701
+
1702
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#117
1547
1703
  class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
1704
+
1705
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22
1548
1706
  class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
1707
+
1708
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102
1549
1709
  module Regexp::Expression::UnicodeProperty::Codepoint; end
1710
+
1711
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105
1550
1712
  class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1713
+
1714
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#103
1551
1715
  class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1716
+
1717
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106
1552
1718
  class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1719
+
1720
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107
1553
1721
  class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1722
+
1723
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109
1554
1724
  class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1725
+
1726
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108
1555
1727
  class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1728
+
1729
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#110
1556
1730
  class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1731
+
1732
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114
1557
1733
  class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
1734
+
1735
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23
1558
1736
  class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
1737
+
1738
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115
1559
1739
  class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
1740
+
1741
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24
1560
1742
  class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
1743
+
1744
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39
1561
1745
  module Regexp::Expression::UnicodeProperty::Letter; end
1746
+
1747
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42
1562
1748
  class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1749
+
1750
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#40
1563
1751
  class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1752
+
1753
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43
1564
1754
  class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1755
+
1756
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45
1565
1757
  class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1758
+
1759
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47
1566
1760
  class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1761
+
1762
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#48
1567
1763
  class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1764
+
1765
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46
1568
1766
  class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1767
+
1768
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44
1569
1769
  class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1770
+
1771
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25
1570
1772
  class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
1773
+
1774
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51
1571
1775
  module Regexp::Expression::UnicodeProperty::Mark; end
1776
+
1777
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54
1572
1778
  class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1779
+
1780
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#52
1573
1781
  class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1782
+
1783
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55
1574
1784
  class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1785
+
1786
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#58
1575
1787
  class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1788
+
1789
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56
1576
1790
  class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1791
+
1792
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57
1577
1793
  class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1794
+
1795
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#34
1578
1796
  class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
1797
+
1798
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61
1579
1799
  module Regexp::Expression::UnicodeProperty::Number; end
1800
+
1801
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64
1580
1802
  class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1803
+
1804
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#62
1581
1805
  class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1806
+
1807
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65
1582
1808
  class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1809
+
1810
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66
1583
1811
  class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1812
+
1813
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#67
1584
1814
  class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1815
+
1816
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26
1585
1817
  class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
1818
+
1819
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27
1586
1820
  class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
1821
+
1822
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70
1587
1823
  module Regexp::Expression::UnicodeProperty::Punctuation; end
1824
+
1825
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73
1588
1826
  class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1827
+
1828
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#71
1589
1829
  class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1830
+
1831
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77
1590
1832
  class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1833
+
1834
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74
1591
1835
  class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1836
+
1837
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75
1592
1838
  class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1839
+
1840
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79
1593
1841
  class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1842
+
1843
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78
1594
1844
  class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1845
+
1846
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76
1595
1847
  class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1848
+
1849
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#80
1596
1850
  class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1851
+
1852
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116
1597
1853
  class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
1854
+
1855
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83
1598
1856
  module Regexp::Expression::UnicodeProperty::Separator; end
1857
+
1858
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86
1599
1859
  class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1860
+
1861
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#84
1600
1862
  class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1863
+
1864
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88
1601
1865
  class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1866
+
1867
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#89
1602
1868
  class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1869
+
1870
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87
1603
1871
  class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1872
+
1873
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28
1604
1874
  class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
1875
+
1876
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92
1605
1877
  module Regexp::Expression::UnicodeProperty::Symbol; end
1878
+
1879
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95
1606
1880
  class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1881
+
1882
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#93
1607
1883
  class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1884
+
1885
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97
1608
1886
  class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1887
+
1888
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96
1609
1889
  class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1890
+
1891
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98
1610
1892
  class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1893
+
1894
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#99
1611
1895
  class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1896
+
1897
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29
1612
1898
  class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
1899
+
1900
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30
1613
1901
  class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
1902
+
1903
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#32
1614
1904
  class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
1905
+
1906
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31
1615
1907
  class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
1616
1908
 
1909
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#10
1617
1910
  class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
1618
1911
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42
1619
1912
  def human_name; end
@@ -1626,96 +1919,153 @@ end
1626
1919
  # collects emitted tokens into an array, calculates their nesting depth, and
1627
1920
  # normalizes tokens for the parser, and checks if they are implemented by the
1628
1921
  # given syntax flavor.
1922
+ #
1923
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#5
1629
1924
  class Regexp::Lexer
1925
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1926
+ def emit(token); end
1927
+
1630
1928
  # source://regexp_parser//lib/regexp_parser/lexer.rb#20
1631
- def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
1929
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1632
1930
 
1633
1931
  private
1634
1932
 
1635
- # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1933
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#91
1636
1934
  def ascend(type, token); end
1637
1935
 
1638
- # source://regexp_parser//lib/regexp_parser/lexer.rb#108
1936
+ # Returns the value of attribute block.
1937
+ #
1938
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1939
+ def block; end
1940
+
1941
+ # Sets the attribute block
1942
+ #
1943
+ # @param value the value to set the attribute block to.
1944
+ #
1945
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1946
+ def block=(_arg0); end
1947
+
1948
+ # if a codepoint list is followed by a quantifier, that quantifier applies
1949
+ # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
1950
+ # c.f. #break_literal.
1951
+ #
1952
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#135
1639
1953
  def break_codepoint_list(token); end
1640
1954
 
1641
1955
  # called by scan to break a literal run that is longer than one character
1642
1956
  # into two separate tokens when it is followed by a quantifier
1643
1957
  #
1644
- # source://regexp_parser//lib/regexp_parser/lexer.rb#95
1958
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#115
1645
1959
  def break_literal(token); end
1646
1960
 
1961
+ # Returns the value of attribute collect_tokens.
1962
+ #
1963
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1964
+ def collect_tokens; end
1965
+
1966
+ # Sets the attribute collect_tokens
1967
+ #
1968
+ # @param value the value to set the attribute collect_tokens to.
1969
+ #
1970
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1971
+ def collect_tokens=(_arg0); end
1972
+
1647
1973
  # Returns the value of attribute conditional_nesting.
1648
1974
  #
1649
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1975
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1650
1976
  def conditional_nesting; end
1651
1977
 
1652
1978
  # Sets the attribute conditional_nesting
1653
1979
  #
1654
1980
  # @param value the value to set the attribute conditional_nesting to.
1655
1981
  #
1656
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1982
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1657
1983
  def conditional_nesting=(_arg0); end
1658
1984
 
1659
- # source://regexp_parser//lib/regexp_parser/lexer.rb#82
1985
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#102
1660
1986
  def descend(type, token); end
1661
1987
 
1662
- # source://regexp_parser//lib/regexp_parser/lexer.rb#123
1663
- def merge_condition(current); end
1988
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#154
1989
+ def merge_condition(current, last); end
1664
1990
 
1665
1991
  # Returns the value of attribute nesting.
1666
1992
  #
1667
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1993
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1668
1994
  def nesting; end
1669
1995
 
1670
1996
  # Sets the attribute nesting
1671
1997
  #
1672
1998
  # @param value the value to set the attribute nesting to.
1673
1999
  #
1674
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2000
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1675
2001
  def nesting=(_arg0); end
1676
2002
 
2003
+ # Returns the value of attribute preprev_token.
2004
+ #
2005
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2006
+ def preprev_token; end
2007
+
2008
+ # Sets the attribute preprev_token
2009
+ #
2010
+ # @param value the value to set the attribute preprev_token to.
2011
+ #
2012
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2013
+ def preprev_token=(_arg0); end
2014
+
2015
+ # Returns the value of attribute prev_token.
2016
+ #
2017
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2018
+ def prev_token; end
2019
+
2020
+ # Sets the attribute prev_token
2021
+ #
2022
+ # @param value the value to set the attribute prev_token to.
2023
+ #
2024
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2025
+ def prev_token=(_arg0); end
2026
+
1677
2027
  # Returns the value of attribute set_nesting.
1678
2028
  #
1679
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2029
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1680
2030
  def set_nesting; end
1681
2031
 
1682
2032
  # Sets the attribute set_nesting
1683
2033
  #
1684
2034
  # @param value the value to set the attribute set_nesting to.
1685
2035
  #
1686
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2036
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1687
2037
  def set_nesting=(_arg0); end
1688
2038
 
1689
2039
  # Returns the value of attribute shift.
1690
2040
  #
1691
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2041
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1692
2042
  def shift; end
1693
2043
 
1694
2044
  # Sets the attribute shift
1695
2045
  #
1696
2046
  # @param value the value to set the attribute shift to.
1697
2047
  #
1698
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2048
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1699
2049
  def shift=(_arg0); end
1700
2050
 
1701
2051
  # Returns the value of attribute tokens.
1702
2052
  #
1703
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2053
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1704
2054
  def tokens; end
1705
2055
 
1706
2056
  # Sets the attribute tokens
1707
2057
  #
1708
2058
  # @param value the value to set the attribute tokens to.
1709
2059
  #
1710
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2060
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1711
2061
  def tokens=(_arg0); end
1712
2062
 
1713
2063
  class << self
1714
2064
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1715
- def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2065
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1716
2066
 
1717
2067
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1718
- def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2068
+ def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1719
2069
  end
1720
2070
  end
1721
2071
 
@@ -1728,6 +2078,7 @@ Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
1728
2078
  # source://regexp_parser//lib/regexp_parser/lexer.rb#7
1729
2079
  Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
1730
2080
 
2081
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1
1731
2082
  class Regexp::MatchLength
1732
2083
  include ::Enumerable
1733
2084
 
@@ -1841,7 +2192,7 @@ class Regexp::MatchLength
1841
2192
  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
1842
2193
  def reify=(_arg0); end
1843
2194
 
1844
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#73
2195
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74
1845
2196
  def test_regexp; end
1846
2197
 
1847
2198
  class << self
@@ -1850,6 +2201,7 @@ class Regexp::MatchLength
1850
2201
  end
1851
2202
  end
1852
2203
 
2204
+ # source://regexp_parser//lib/regexp_parser/version.rb#2
1853
2205
  class Regexp::Parser
1854
2206
  include ::Regexp::Expression
1855
2207
  include ::Regexp::Expression::UnicodeProperty
@@ -2067,16 +2419,20 @@ end
2067
2419
  Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
2068
2420
 
2069
2421
  # base class for all gem-specific errors
2422
+ #
2423
+ # source://regexp_parser//lib/regexp_parser/error.rb#3
2070
2424
  class Regexp::Parser::Error < ::StandardError; end
2071
2425
 
2072
2426
  # source://regexp_parser//lib/regexp_parser/parser.rb#127
2073
2427
  Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
2074
2428
 
2429
+ # source://regexp_parser//lib/regexp_parser/parser.rb#7
2075
2430
  class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
2076
2431
 
2077
2432
  # source://regexp_parser//lib/regexp_parser/parser.rb#397
2078
2433
  Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
2079
2434
 
2435
+ # source://regexp_parser//lib/regexp_parser/parser.rb#15
2080
2436
  class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2081
2437
  # @return [UnknownTokenError] a new instance of UnknownTokenError
2082
2438
  #
@@ -2084,6 +2440,7 @@ class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2084
2440
  def initialize(type, token); end
2085
2441
  end
2086
2442
 
2443
+ # source://regexp_parser//lib/regexp_parser/parser.rb#9
2087
2444
  class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
2088
2445
  # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError
2089
2446
  #
@@ -2094,178 +2451,201 @@ end
2094
2451
  # source://regexp_parser//lib/regexp_parser/version.rb#3
2095
2452
  Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
2096
2453
 
2454
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#13
2097
2455
  class Regexp::Scanner
2098
2456
  # Emits an array with the details of the scanned pattern
2099
2457
  #
2100
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2555
2458
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2101
2459
  def emit(type, token, text); end
2102
2460
 
2461
+ # only public for #||= to work on ruby <= 2.5
2462
+ #
2463
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2616
2464
+ def literal_run; end
2465
+
2466
+ # only public for #||= to work on ruby <= 2.5
2467
+ #
2468
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2616
2469
+ def literal_run=(_arg0); end
2470
+
2103
2471
  # @raise [PrematureEndError]
2104
2472
  #
2105
2473
  # source://regexp_parser//lib/regexp_parser/scanner.rb#84
2106
- def scan(input_object, options: T.unsafe(nil), &block); end
2474
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2107
2475
 
2108
2476
  private
2109
2477
 
2110
2478
  # Appends one or more characters to the literal buffer, to be emitted later
2111
2479
  # by a call to emit_literal.
2112
2480
  #
2113
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2606
2481
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2653
2114
2482
  def append_literal(data, ts, te); end
2115
2483
 
2116
2484
  # Returns the value of attribute block.
2117
2485
  #
2118
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2486
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2119
2487
  def block; end
2120
2488
 
2121
2489
  # Sets the attribute block
2122
2490
  #
2123
2491
  # @param value the value to set the attribute block to.
2124
2492
  #
2125
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2493
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2126
2494
  def block=(_arg0); end
2127
2495
 
2128
2496
  # Returns the value of attribute char_pos.
2129
2497
  #
2130
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2498
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2131
2499
  def char_pos; end
2132
2500
 
2133
2501
  # Sets the attribute char_pos
2134
2502
  #
2135
2503
  # @param value the value to set the attribute char_pos to.
2136
2504
  #
2137
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2505
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2138
2506
  def char_pos=(_arg0); end
2139
2507
 
2508
+ # Returns the value of attribute collect_tokens.
2509
+ #
2510
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2511
+ def collect_tokens; end
2512
+
2513
+ # Sets the attribute collect_tokens
2514
+ #
2515
+ # @param value the value to set the attribute collect_tokens to.
2516
+ #
2517
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2518
+ def collect_tokens=(_arg0); end
2519
+
2140
2520
  # Returns the value of attribute conditional_stack.
2141
2521
  #
2142
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2522
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2143
2523
  def conditional_stack; end
2144
2524
 
2145
2525
  # Sets the attribute conditional_stack
2146
2526
  #
2147
2527
  # @param value the value to set the attribute conditional_stack to.
2148
2528
  #
2149
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2529
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2150
2530
  def conditional_stack=(_arg0); end
2151
2531
 
2152
2532
  # Copy from ts to te from data as text
2153
2533
  #
2154
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2600
2534
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2155
2535
  def copy(data, ts, te); end
2156
2536
 
2157
2537
  # Emits the literal run collected by calls to the append_literal method.
2158
2538
  #
2159
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2612
2539
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2658
2160
2540
  def emit_literal; end
2161
2541
 
2162
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2542
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2693
2163
2543
  def emit_meta_control_sequence(data, ts, te, token); end
2164
2544
 
2165
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2618
2545
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2664
2166
2546
  def emit_options(text); end
2167
2547
 
2168
2548
  # Returns the value of attribute free_spacing.
2169
2549
  #
2170
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2550
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2171
2551
  def free_spacing; end
2172
2552
 
2173
2553
  # Sets the attribute free_spacing
2174
2554
  #
2175
2555
  # @param value the value to set the attribute free_spacing to.
2176
2556
  #
2177
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2557
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2178
2558
  def free_spacing=(_arg0); end
2179
2559
 
2180
2560
  # @return [Boolean]
2181
2561
  #
2182
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2579
2562
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2626
2183
2563
  def free_spacing?(input_object, options); end
2184
2564
 
2185
2565
  # Returns the value of attribute group_depth.
2186
2566
  #
2187
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2567
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2188
2568
  def group_depth; end
2189
2569
 
2190
2570
  # Sets the attribute group_depth
2191
2571
  #
2192
2572
  # @param value the value to set the attribute group_depth to.
2193
2573
  #
2194
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2574
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2195
2575
  def group_depth=(_arg0); end
2196
2576
 
2197
2577
  # @return [Boolean]
2198
2578
  #
2199
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2579
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2638
2200
2580
  def in_group?; end
2201
2581
 
2202
2582
  # @return [Boolean]
2203
2583
  #
2204
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2595
2584
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2642
2205
2585
  def in_set?; end
2206
2586
 
2207
- # Returns the value of attribute literal.
2587
+ # Returns the value of attribute prev_token.
2208
2588
  #
2209
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2210
- def literal; end
2589
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2590
+ def prev_token; end
2211
2591
 
2212
- # Sets the attribute literal
2592
+ # Sets the attribute prev_token
2213
2593
  #
2214
- # @param value the value to set the attribute literal to.
2594
+ # @param value the value to set the attribute prev_token to.
2215
2595
  #
2216
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2217
- def literal=(_arg0); end
2596
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2597
+ def prev_token=(_arg0); end
2218
2598
 
2219
2599
  # Returns the value of attribute set_depth.
2220
2600
  #
2221
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2601
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2222
2602
  def set_depth; end
2223
2603
 
2224
2604
  # Sets the attribute set_depth
2225
2605
  #
2226
2606
  # @param value the value to set the attribute set_depth to.
2227
2607
  #
2228
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2608
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2229
2609
  def set_depth=(_arg0); end
2230
2610
 
2231
2611
  # Returns the value of attribute spacing_stack.
2232
2612
  #
2233
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2613
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2234
2614
  def spacing_stack; end
2235
2615
 
2236
2616
  # Sets the attribute spacing_stack
2237
2617
  #
2238
2618
  # @param value the value to set the attribute spacing_stack to.
2239
2619
  #
2240
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2620
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2241
2621
  def spacing_stack=(_arg0); end
2242
2622
 
2243
2623
  # Returns the value of attribute tokens.
2244
2624
  #
2245
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2625
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2246
2626
  def tokens; end
2247
2627
 
2248
2628
  # Sets the attribute tokens
2249
2629
  #
2250
2630
  # @param value the value to set the attribute tokens to.
2251
2631
  #
2252
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2632
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2253
2633
  def tokens=(_arg0); end
2254
2634
 
2255
2635
  # Centralizes and unifies the handling of validation related
2256
2636
  # errors.
2257
2637
  #
2258
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2656
2638
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2702
2259
2639
  def validation_error(type, what, reason = T.unsafe(nil)); end
2260
2640
 
2261
2641
  class << self
2262
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2541
2642
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2577
2263
2643
  def long_prop_map; end
2264
2644
 
2265
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2545
2645
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2581
2266
2646
  def parse_prop_map(name); end
2267
2647
 
2268
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2549
2648
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2585
2269
2649
  def posix_classes; end
2270
2650
 
2271
2651
  # Scans the given regular expression text, or Regexp object and collects the
@@ -2276,16 +2656,18 @@ class Regexp::Scanner
2276
2656
  # --------------------------------------------------------------------------
2277
2657
  #
2278
2658
  # source://regexp_parser//lib/regexp_parser/scanner.rb#80
2279
- def scan(input_object, options: T.unsafe(nil), &block); end
2659
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2280
2660
 
2281
2661
  # lazy-load property maps when first needed
2282
2662
  #
2283
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2537
2663
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2573
2284
2664
  def short_prop_map; end
2285
2665
  end
2286
2666
  end
2287
2667
 
2288
2668
  # Invalid back reference. Used for name a number refs/calls.
2669
+ #
2670
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#54
2289
2671
  class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2290
2672
  # @return [InvalidBackrefError] a new instance of InvalidBackrefError
2291
2673
  #
@@ -2294,6 +2676,8 @@ class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2294
2676
  end
2295
2677
 
2296
2678
  # Invalid group. Used for named groups.
2679
+ #
2680
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#39
2297
2681
  class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
2298
2682
  # @return [InvalidGroupError] a new instance of InvalidGroupError
2299
2683
  #
@@ -2303,6 +2687,8 @@ end
2303
2687
 
2304
2688
  # Invalid groupOption. Used for inline options.
2305
2689
  # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
2690
+ #
2691
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#47
2306
2692
  class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2307
2693
  # @return [InvalidGroupOption] a new instance of InvalidGroupOption
2308
2694
  #
@@ -2311,6 +2697,8 @@ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2311
2697
  end
2312
2698
 
2313
2699
  # Invalid sequence format. Used for escape sequences, mainly.
2700
+ #
2701
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#32
2314
2702
  class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2315
2703
  # @return [InvalidSequenceError] a new instance of InvalidSequenceError
2316
2704
  #
@@ -2319,6 +2707,8 @@ class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2319
2707
  end
2320
2708
 
2321
2709
  # Unexpected end of pattern
2710
+ #
2711
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#25
2322
2712
  class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2323
2713
  # @return [PrematureEndError] a new instance of PrematureEndError
2324
2714
  #
@@ -2327,9 +2717,13 @@ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2327
2717
  end
2328
2718
 
2329
2719
  # General scanner error (catch all)
2720
+ #
2721
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#15
2330
2722
  class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
2331
2723
 
2332
2724
  # The POSIX class name was not recognized by the scanner.
2725
+ #
2726
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#68
2333
2727
  class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
2334
2728
  # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError
2335
2729
  #
@@ -2338,6 +2732,8 @@ class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationErr
2338
2732
  end
2339
2733
 
2340
2734
  # The property name was not recognized by the scanner.
2735
+ #
2736
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#61
2341
2737
  class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
2342
2738
  # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError
2343
2739
  #
@@ -2346,6 +2742,8 @@ class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::Validati
2346
2742
  end
2347
2743
 
2348
2744
  # Base for all scanner validation errors
2745
+ #
2746
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#18
2349
2747
  class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error
2350
2748
  # @return [ValidationError] a new instance of ValidationError
2351
2749
  #
@@ -2355,16 +2753,18 @@ end
2355
2753
 
2356
2754
  # After loading all the tokens the map is full. Extract all tokens and types
2357
2755
  # into the All and Types constants.
2756
+ #
2757
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#3
2358
2758
  module Regexp::Syntax
2359
2759
  private
2360
2760
 
2361
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2761
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2362
2762
  def comparable(name); end
2363
2763
 
2364
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2764
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2365
2765
  def const_missing(const_name); end
2366
2766
 
2367
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2767
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2368
2768
  def fallback_version_class(version); end
2369
2769
 
2370
2770
  # Returns the syntax specification class for the given syntax
@@ -2376,7 +2776,7 @@ module Regexp::Syntax
2376
2776
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2377
2777
  def new(name); end
2378
2778
 
2379
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2779
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2380
2780
  def specified_versions; end
2381
2781
 
2382
2782
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
@@ -2385,17 +2785,14 @@ module Regexp::Syntax
2385
2785
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2386
2786
  def version_class(version); end
2387
2787
 
2388
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2389
- def warn_if_future_version(const_name); end
2390
-
2391
2788
  class << self
2392
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2789
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2393
2790
  def comparable(name); end
2394
2791
 
2395
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2792
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2396
2793
  def const_missing(const_name); end
2397
2794
 
2398
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2795
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2399
2796
  def fallback_version_class(version); end
2400
2797
 
2401
2798
  # Returns the syntax specification class for the given syntax
@@ -2407,7 +2804,7 @@ module Regexp::Syntax
2407
2804
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2408
2805
  def new(name); end
2409
2806
 
2410
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2807
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2411
2808
  def specified_versions; end
2412
2809
 
2413
2810
  # @return [Boolean]
@@ -2417,15 +2814,14 @@ module Regexp::Syntax
2417
2814
 
2418
2815
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2419
2816
  def version_class(version); end
2420
-
2421
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2422
- def warn_if_future_version(const_name); end
2423
2817
  end
2424
2818
  end
2425
2819
 
2426
2820
  # A syntax that always returns true, passing all tokens as implemented. This
2427
2821
  # is useful during development, testing, and should be useful for some types
2428
2822
  # of transformations as well.
2823
+ #
2824
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#5
2429
2825
  class Regexp::Syntax::Any < ::Regexp::Syntax::Base
2430
2826
  class << self
2431
2827
  # @return [Boolean]
@@ -2436,6 +2832,8 @@ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
2436
2832
  end
2437
2833
 
2438
2834
  # A lookup map of supported types and tokens in a given syntax
2835
+ #
2836
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#9
2439
2837
  class Regexp::Syntax::Base
2440
2838
  include ::Regexp::Syntax::Token
2441
2839
 
@@ -2520,6 +2918,10 @@ class Regexp::Syntax::Base
2520
2918
  end
2521
2919
  end
2522
2920
 
2921
+ # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
2922
+ Regexp::Syntax::CURRENT = Regexp::Syntax::V3_2_0
2923
+
2924
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
2523
2925
  class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
2524
2926
  # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError
2525
2927
  #
@@ -2527,6 +2929,7 @@ class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
2527
2929
  def initialize(name); end
2528
2930
  end
2529
2931
 
2932
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#2
2530
2933
  class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
2531
2934
  # @return [NotImplementedError] a new instance of NotImplementedError
2532
2935
  #
@@ -2534,12 +2937,16 @@ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
2534
2937
  def initialize(syntax, type, token); end
2535
2938
  end
2536
2939
 
2940
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#4
2537
2941
  class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
2942
+
2943
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#3
2538
2944
  module Regexp::Syntax::Token; end
2539
2945
 
2540
2946
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#42
2541
2947
  Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
2542
2948
 
2949
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3
2543
2950
  module Regexp::Syntax::Token::Anchor; end
2544
2951
 
2545
2952
  # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9
@@ -2560,6 +2967,7 @@ Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
2560
2967
  # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10
2561
2968
  Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
2562
2969
 
2970
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3
2563
2971
  module Regexp::Syntax::Token::Assertion; end
2564
2972
 
2565
2973
  # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7
@@ -2574,6 +2982,7 @@ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
2574
2982
  # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8
2575
2983
  Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
2576
2984
 
2985
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3
2577
2986
  module Regexp::Syntax::Token::Backreference; end
2578
2987
 
2579
2988
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15
@@ -2603,6 +3012,7 @@ Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
2603
3012
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13
2604
3013
  Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
2605
3014
 
3015
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3
2606
3016
  module Regexp::Syntax::Token::CharacterSet; end
2607
3017
 
2608
3018
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7
@@ -2617,6 +3027,7 @@ Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
2617
3027
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8
2618
3028
  Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
2619
3029
 
3030
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3
2620
3031
  module Regexp::Syntax::Token::CharacterType; end
2621
3032
 
2622
3033
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10
@@ -2637,6 +3048,7 @@ Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
2637
3048
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11
2638
3049
  Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
2639
3050
 
3051
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3
2640
3052
  module Regexp::Syntax::Token::Conditional; end
2641
3053
 
2642
3054
  # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9
@@ -2655,6 +3067,8 @@ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
2655
3067
  Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
2656
3068
 
2657
3069
  # TODO: unify naming with RE::EscapeSequence, one way or the other, in v3.0.0
3070
+ #
3071
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4
2658
3072
  module Regexp::Syntax::Token::Escape; end
2659
3073
 
2660
3074
  # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#9
@@ -2684,6 +3098,7 @@ Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
2684
3098
  # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#12
2685
3099
  Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
2686
3100
 
3101
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#11
2687
3102
  module Regexp::Syntax::Token::FreeSpace; end
2688
3103
 
2689
3104
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#12
@@ -2692,6 +3107,7 @@ Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
2692
3107
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#13
2693
3108
  Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
2694
3109
 
3110
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3
2695
3111
  module Regexp::Syntax::Token::Group; end
2696
3112
 
2697
3113
  # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17
@@ -2724,6 +3140,7 @@ Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
2724
3140
  # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15
2725
3141
  Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
2726
3142
 
3143
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3
2727
3144
  module Regexp::Syntax::Token::Keep; end
2728
3145
 
2729
3146
  # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6
@@ -2735,6 +3152,7 @@ Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
2735
3152
  # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7
2736
3153
  Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
2737
3154
 
3155
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#6
2738
3156
  module Regexp::Syntax::Token::Literal; end
2739
3157
 
2740
3158
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#7
@@ -2746,6 +3164,7 @@ Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
2746
3164
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#4
2747
3165
  Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
2748
3166
 
3167
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3
2749
3168
  module Regexp::Syntax::Token::Meta; end
2750
3169
 
2751
3170
  # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#7
@@ -2760,6 +3179,7 @@ Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
2760
3179
  # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8
2761
3180
  Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
2762
3181
 
3182
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3
2763
3183
  module Regexp::Syntax::Token::PosixClass; end
2764
3184
 
2765
3185
  # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9
@@ -2777,6 +3197,7 @@ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
2777
3197
  # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10
2778
3198
  Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
2779
3199
 
3200
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3
2780
3201
  module Regexp::Syntax::Token::Quantifier; end
2781
3202
 
2782
3203
  # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29
@@ -2810,6 +3231,8 @@ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
2810
3231
  Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
2811
3232
 
2812
3233
  # Type is the same as Backreference so keeping it here, for now.
3234
+ #
3235
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20
2813
3236
  module Regexp::Syntax::Token::SubexpressionCall; end
2814
3237
 
2815
3238
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24
@@ -2824,6 +3247,7 @@ Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
2824
3247
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#43
2825
3248
  Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
2826
3249
 
3250
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3
2827
3251
  module Regexp::Syntax::Token::UnicodeProperty; end
2828
3252
 
2829
3253
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64
@@ -2865,6 +3289,7 @@ Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
2865
3289
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708
2866
3290
  Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
2867
3291
 
3292
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13
2868
3293
  module Regexp::Syntax::Token::UnicodeProperty::Category; end
2869
3294
 
2870
3295
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36
@@ -3032,6 +3457,7 @@ Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
3032
3457
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706
3033
3458
  Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
3034
3459
 
3460
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12
3035
3461
  class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3036
3462
  # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError
3037
3463
  #
@@ -3039,19 +3465,46 @@ class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3039
3465
  def initialize(name); end
3040
3466
  end
3041
3467
 
3468
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1
3042
3469
  class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
3470
+
3471
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1
3043
3472
  class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
3473
+
3474
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1
3044
3475
  class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
3476
+
3477
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1
3045
3478
  class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
3479
+
3480
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1
3046
3481
  class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
3482
+
3483
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1
3047
3484
  class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
3485
+
3486
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1
3048
3487
  class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
3488
+
3489
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1
3049
3490
  class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
3491
+
3492
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1
3050
3493
  class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
3494
+
3495
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1
3051
3496
  class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
3497
+
3498
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1
3052
3499
  class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
3500
+
3501
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1
3053
3502
  class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
3503
+
3504
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1
3054
3505
  class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
3506
+
3507
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1
3055
3508
  class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
3056
3509
 
3057
3510
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4
@@ -3066,6 +3519,7 @@ Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
3066
3519
  # source://regexp_parser//lib/regexp_parser/token.rb#2
3067
3520
  Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
3068
3521
 
3522
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3069
3523
  class Regexp::Token < ::Struct
3070
3524
  def conditional_level; end
3071
3525
  def conditional_level=(_); end