rspec-sorbet 1.8.1 → 1.8.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (58) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/lib/rspec/sorbet/version.rb +1 -1
  4. data/rspec-sorbet.gemspec +1 -1
  5. metadata +1 -54
  6. data/sorbet/config +0 -4
  7. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  8. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -1568
  9. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -1005
  10. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -9
  11. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  12. data/sorbet/rbi/gems/em-websocket@0.5.2.rbi +0 -8
  13. data/sorbet/rbi/gems/eventmachine@1.2.7.rbi +0 -45
  14. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +0 -3171
  15. data/sorbet/rbi/gems/ffi@1.15.4.rbi +0 -8
  16. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  17. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -31
  18. data/sorbet/rbi/gems/guard-livereload@2.5.2.rbi +0 -8
  19. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -211
  20. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -8
  21. data/sorbet/rbi/gems/http_parser.rb@0.6.0.rbi +0 -8
  22. data/sorbet/rbi/gems/listen@3.7.0.rbi +0 -8
  23. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -8
  24. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -72
  25. data/sorbet/rbi/gems/multi_json@1.15.0.rbi +0 -8
  26. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -8
  27. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -8
  28. data/sorbet/rbi/gems/parallel@1.21.0.rbi +0 -113
  29. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1189
  30. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +0 -458
  31. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -2486
  32. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  33. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -795
  34. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  35. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  36. data/sorbet/rbi/gems/rbi@0.0.6.rbi +0 -1405
  37. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  38. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  39. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2455
  40. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  41. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  42. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  43. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  44. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +0 -1938
  45. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +0 -1786
  46. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +0 -13252
  47. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  48. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -8
  49. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  50. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  51. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  52. data/sorbet/rbi/gems/spoom@1.1.5.rbi +0 -1241
  53. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +0 -98
  54. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +0 -949
  55. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -839
  56. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +0 -26
  57. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -8
  58. data/sorbet/tapioca/require.rb +0 -4
@@ -1,1938 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `rubocop-ast` gem.
3
- # Please instead update this file by running `bin/tapioca gem rubocop-ast`.
4
-
5
- # typed: true
6
-
7
- module RuboCop; end
8
-
9
- module RuboCop::AST
10
- extend ::RuboCop::AST::RuboCopCompatibility
11
- end
12
-
13
- class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
14
- def new_identifier; end
15
- def old_identifier; end
16
- end
17
-
18
- class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode
19
- def operator; end
20
- end
21
-
22
- class RuboCop::AST::AndNode < ::RuboCop::AST::Node
23
- include ::RuboCop::AST::BinaryOperatorNode
24
- include ::RuboCop::AST::PredicateOperatorNode
25
-
26
- def alternate_operator; end
27
- def inverse_operator; end
28
- end
29
-
30
- class RuboCop::AST::ArgNode < ::RuboCop::AST::Node
31
- def default?; end
32
- def default_value; end
33
- def name; end
34
- end
35
-
36
- class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
37
- include ::RuboCop::AST::CollectionNode
38
-
39
- def argument_list; end
40
- def empty_and_without_delimiters?; end
41
- end
42
-
43
- class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
44
- def bracketed?; end
45
- def each_value(&block); end
46
- def percent_literal?(type = T.unsafe(nil)); end
47
- def square_brackets?; end
48
- def values; end
49
- end
50
-
51
- RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
52
-
53
- class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node
54
- def expression; end
55
- def name; end
56
- end
57
-
58
- module RuboCop::AST::BasicLiteralNode
59
- def value; end
60
- end
61
-
62
- module RuboCop::AST::BinaryOperatorNode
63
- def conditions; end
64
- def lhs; end
65
- def rhs; end
66
- end
67
-
68
- class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
69
- include ::RuboCop::AST::MethodIdentifierPredicates
70
-
71
- def argument_list; end
72
- def arguments; end
73
- def arguments?; end
74
- def body; end
75
- def braces?; end
76
- def closing_delimiter; end
77
- def delimiters; end
78
- def keywords?; end
79
- def lambda?; end
80
- def method_name; end
81
- def multiline?; end
82
- def opening_delimiter; end
83
- def send_node; end
84
- def single_line?; end
85
- def void_context?; end
86
-
87
- private
88
-
89
- def numbered_arguments; end
90
- end
91
-
92
- RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
93
-
94
- class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
95
- include ::RuboCop::AST::ParameterizedNode
96
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
97
- end
98
-
99
- class RuboCop::AST::Builder < ::Parser::Builders::Default
100
- def n(type, children, source_map); end
101
- def string_value(token); end
102
-
103
- private
104
-
105
- def node_klass(type); end
106
- end
107
-
108
- RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
109
-
110
- class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
111
- include ::RuboCop::AST::ConditionalNode
112
-
113
- def branches; end
114
- def each_in_pattern(&block); end
115
- def else?; end
116
- def else_branch; end
117
- def in_pattern_branches; end
118
- def keyword; end
119
- end
120
-
121
- class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
122
- include ::RuboCop::AST::ConditionalNode
123
-
124
- def branches; end
125
- def each_when(&block); end
126
- def else?; end
127
- def else_branch; end
128
- def keyword; end
129
- def when_branches; end
130
- end
131
-
132
- class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node
133
- def expression; end
134
- def name; end
135
- def namespace; end
136
- end
137
-
138
- class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
139
- def body; end
140
- def identifier; end
141
- def parent_class; end
142
- end
143
-
144
- module RuboCop::AST::CollectionNode
145
- extend ::Forwardable
146
-
147
- def &(*args, &block); end
148
- def *(*args, &block); end
149
- def +(*args, &block); end
150
- def -(*args, &block); end
151
- def <<(*args, &block); end
152
- def [](*args, &block); end
153
- def []=(*args, &block); end
154
- def all?(*args, &block); end
155
- def any?(*args, &block); end
156
- def append(*args, &block); end
157
- def assoc(*args, &block); end
158
- def at(*args, &block); end
159
- def bsearch(*args, &block); end
160
- def bsearch_index(*args, &block); end
161
- def chain(*args, &block); end
162
- def chunk(*args, &block); end
163
- def chunk_while(*args, &block); end
164
- def clear(*args, &block); end
165
- def collect(*args, &block); end
166
- def collect!(*args, &block); end
167
- def collect_concat(*args, &block); end
168
- def combination(*args, &block); end
169
- def compact(*args, &block); end
170
- def compact!(*args, &block); end
171
- def concat(*args, &block); end
172
- def count(*args, &block); end
173
- def cycle(*args, &block); end
174
- def deconstruct(*args, &block); end
175
- def delete(*args, &block); end
176
- def delete_at(*args, &block); end
177
- def delete_if(*args, &block); end
178
- def detect(*args, &block); end
179
- def difference(*args, &block); end
180
- def dig(*args, &block); end
181
- def drop(*args, &block); end
182
- def drop_while(*args, &block); end
183
- def each(*args, &block); end
184
- def each_cons(*args, &block); end
185
- def each_entry(*args, &block); end
186
- def each_index(*args, &block); end
187
- def each_slice(*args, &block); end
188
- def each_with_index(*args, &block); end
189
- def each_with_object(*args, &block); end
190
- def empty?(*args, &block); end
191
- def entries(*args, &block); end
192
- def fetch(*args, &block); end
193
- def fill(*args, &block); end
194
- def filter(*args, &block); end
195
- def filter!(*args, &block); end
196
- def filter_map(*args, &block); end
197
- def find(*args, &block); end
198
- def find_all(*args, &block); end
199
- def find_index(*args, &block); end
200
- def first(*args, &block); end
201
- def flat_map(*args, &block); end
202
- def flatten(*args, &block); end
203
- def flatten!(*args, &block); end
204
- def grep(*args, &block); end
205
- def grep_v(*args, &block); end
206
- def group_by(*args, &block); end
207
- def include?(*args, &block); end
208
- def index(*args, &block); end
209
- def inject(*args, &block); end
210
- def insert(*args, &block); end
211
- def intersection(*args, &block); end
212
- def join(*args, &block); end
213
- def keep_if(*args, &block); end
214
- def last(*args, &block); end
215
- def lazy(*args, &block); end
216
- def length(*args, &block); end
217
- def map(*args, &block); end
218
- def map!(*args, &block); end
219
- def max(*args, &block); end
220
- def max_by(*args, &block); end
221
- def member?(*args, &block); end
222
- def min(*args, &block); end
223
- def min_by(*args, &block); end
224
- def minmax(*args, &block); end
225
- def minmax_by(*args, &block); end
226
- def none?(*args, &block); end
227
- def one?(*args, &block); end
228
- def pack(*args, &block); end
229
- def partition(*args, &block); end
230
- def permutation(*args, &block); end
231
- def pop(*args, &block); end
232
- def prepend(*args, &block); end
233
- def product(*args, &block); end
234
- def push(*args, &block); end
235
- def rassoc(*args, &block); end
236
- def reduce(*args, &block); end
237
- def reject(*args, &block); end
238
- def reject!(*args, &block); end
239
- def repeated_combination(*args, &block); end
240
- def repeated_permutation(*args, &block); end
241
- def replace(*args, &block); end
242
- def reverse(*args, &block); end
243
- def reverse!(*args, &block); end
244
- def reverse_each(*args, &block); end
245
- def rindex(*args, &block); end
246
- def rotate(*args, &block); end
247
- def rotate!(*args, &block); end
248
- def sample(*args, &block); end
249
- def select(*args, &block); end
250
- def select!(*args, &block); end
251
- def shelljoin(*args, &block); end
252
- def shift(*args, &block); end
253
- def shuffle(*args, &block); end
254
- def shuffle!(*args, &block); end
255
- def size(*args, &block); end
256
- def slice(*args, &block); end
257
- def slice!(*args, &block); end
258
- def slice_after(*args, &block); end
259
- def slice_before(*args, &block); end
260
- def slice_when(*args, &block); end
261
- def sort(*args, &block); end
262
- def sort!(*args, &block); end
263
- def sort_by(*args, &block); end
264
- def sort_by!(*args, &block); end
265
- def sum(*args, &block); end
266
- def take(*args, &block); end
267
- def take_while(*args, &block); end
268
- def tally(*args, &block); end
269
- def to_ary(*args, &block); end
270
- def to_h(*args, &block); end
271
- def to_set(*args, &block); end
272
- def transpose(*args, &block); end
273
- def union(*args, &block); end
274
- def uniq(*args, &block); end
275
- def uniq!(*args, &block); end
276
- def unshift(*args, &block); end
277
- def values_at(*args, &block); end
278
- def zip(*args, &block); end
279
- def |(*args, &block); end
280
- end
281
-
282
- RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
283
-
284
- module RuboCop::AST::ConditionalNode
285
- def body; end
286
- def condition; end
287
- def multiline_condition?; end
288
- def single_line_condition?; end
289
- end
290
-
291
- class RuboCop::AST::ConstNode < ::RuboCop::AST::Node
292
- def absolute?; end
293
- def class_name?; end
294
- def each_path(&block); end
295
- def module_name?; end
296
- def namespace; end
297
- def relative?; end
298
- def short_name; end
299
- end
300
-
301
- class RuboCop::AST::DefNode < ::RuboCop::AST::Node
302
- include ::RuboCop::AST::ParameterizedNode
303
- include ::RuboCop::AST::MethodIdentifierPredicates
304
-
305
- def argument_forwarding?; end
306
- def arguments; end
307
- def body; end
308
- def endless?; end
309
- def method_name; end
310
- def receiver; end
311
- def void_context?; end
312
- end
313
-
314
- class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
315
- include ::RuboCop::AST::ParameterizedNode
316
- include ::RuboCop::AST::MethodIdentifierPredicates
317
- include ::RuboCop::AST::MethodDispatchNode
318
-
319
- def arguments; end
320
- def node_parts; end
321
- end
322
-
323
- module RuboCop::AST::Descendence
324
- def child_nodes; end
325
- def descendants; end
326
- def each_child_node(*types); end
327
- def each_descendant(*types, &block); end
328
- def each_node(*types, &block); end
329
-
330
- protected
331
-
332
- def visit_descendants(types, &block); end
333
- end
334
-
335
- class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
336
- def value; end
337
- end
338
-
339
- class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
340
- def body; end
341
- end
342
-
343
- module RuboCop::AST::Ext; end
344
-
345
- module RuboCop::AST::Ext::Range
346
- def line_span(exclude_end: T.unsafe(nil)); end
347
- end
348
-
349
- module RuboCop::AST::Ext::RangeMinMax; end
350
-
351
- class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
352
- include ::RuboCop::AST::BasicLiteralNode
353
- include ::RuboCop::AST::NumericNode
354
- end
355
-
356
- class RuboCop::AST::ForNode < ::RuboCop::AST::Node
357
- def body; end
358
- def collection; end
359
- def do?; end
360
- def keyword; end
361
- def variable; end
362
- def void_context?; end
363
- end
364
-
365
- class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
366
- include ::RuboCop::AST::CollectionNode
367
-
368
- def to_a; end
369
- end
370
-
371
- module RuboCop::AST::HashElementNode
372
- def delimiter_delta(other); end
373
- def key; end
374
- def key_delta(other, alignment = T.unsafe(nil)); end
375
- def same_line?(other); end
376
- def value; end
377
- def value_delta(other); end
378
- end
379
-
380
- class RuboCop::AST::HashElementNode::HashElementDelta
381
- def initialize(first, second); end
382
-
383
- def delimiter_delta; end
384
- def key_delta(alignment = T.unsafe(nil)); end
385
- def value_delta; end
386
-
387
- private
388
-
389
- def delta(first, second, alignment = T.unsafe(nil)); end
390
- def first; end
391
- def keyword_splat?; end
392
- def second; end
393
- def valid_argument_types?; end
394
- end
395
-
396
- class RuboCop::AST::HashNode < ::RuboCop::AST::Node
397
- def braces?; end
398
- def each_key(&block); end
399
- def each_pair; end
400
- def each_value(&block); end
401
- def empty?; end
402
- def keys; end
403
- def mixed_delimiters?; end
404
- def pairs; end
405
- def pairs_on_same_line?; end
406
- def values; end
407
- end
408
-
409
- class RuboCop::AST::IfNode < ::RuboCop::AST::Node
410
- include ::RuboCop::AST::ConditionalNode
411
- include ::RuboCop::AST::ModifierNode
412
-
413
- def branches; end
414
- def each_branch(&block); end
415
- def else?; end
416
- def else_branch; end
417
- def elsif?; end
418
- def elsif_conditional?; end
419
- def if?; end
420
- def if_branch; end
421
- def inverse_keyword; end
422
- def keyword; end
423
- def modifier_form?; end
424
- def nested_conditional?; end
425
- def node_parts; end
426
- def ternary?; end
427
- def unless?; end
428
- end
429
-
430
- class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node
431
- def body; end
432
- def branch_index; end
433
- def pattern; end
434
- def then?; end
435
- end
436
-
437
- class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
438
- include ::RuboCop::AST::ParameterizedNode
439
- include ::RuboCop::AST::ParameterizedNode::RestArguments
440
- include ::RuboCop::AST::MethodIdentifierPredicates
441
- include ::RuboCop::AST::MethodDispatchNode
442
-
443
- def assignment_method?; end
444
- def attribute_accessor?; end
445
- def method_name; end
446
-
447
- private
448
-
449
- def first_argument_index; end
450
- end
451
-
452
- class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
453
- include ::RuboCop::AST::ParameterizedNode
454
- include ::RuboCop::AST::ParameterizedNode::RestArguments
455
- include ::RuboCop::AST::MethodIdentifierPredicates
456
- include ::RuboCop::AST::MethodDispatchNode
457
-
458
- def assignment_method?; end
459
- def attribute_accessor?; end
460
- def method_name; end
461
-
462
- private
463
-
464
- def first_argument_index; end
465
- end
466
-
467
- class RuboCop::AST::IntNode < ::RuboCop::AST::Node
468
- include ::RuboCop::AST::BasicLiteralNode
469
- include ::RuboCop::AST::NumericNode
470
- end
471
-
472
- class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
473
- include ::RuboCop::AST::HashElementNode
474
-
475
- def colon?; end
476
- def hash_rocket?; end
477
- def node_parts; end
478
- def operator; end
479
- end
480
-
481
- RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
482
-
483
- class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
484
- include ::RuboCop::AST::ParameterizedNode
485
- include ::RuboCop::AST::ParameterizedNode::RestArguments
486
- include ::RuboCop::AST::MethodIdentifierPredicates
487
- include ::RuboCop::AST::MethodDispatchNode
488
-
489
- def assignment_method?; end
490
- def attribute_accessor?; end
491
- def lambda?; end
492
- def lambda_literal?; end
493
- def method_name; end
494
- def receiver; end
495
-
496
- private
497
-
498
- def first_argument_index; end
499
- end
500
-
501
- module RuboCop::AST::MethodDispatchNode
502
- include ::RuboCop::AST::MethodIdentifierPredicates
503
- extend ::RuboCop::AST::NodePattern::Macros
504
-
505
- def access_modifier?; end
506
- def adjacent_def_modifier?(param0 = T.unsafe(nil)); end
507
- def arithmetic_operation?; end
508
- def assignment?; end
509
- def bare_access_modifier?; end
510
- def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
511
- def binary_operation?; end
512
- def block_literal?; end
513
- def block_node; end
514
- def command?(name); end
515
- def const_receiver?; end
516
- def def_modifier(node = T.unsafe(nil)); end
517
- def def_modifier?(node = T.unsafe(nil)); end
518
- def dot?; end
519
- def double_colon?; end
520
- def implicit_call?; end
521
- def in_macro_scope?(param0 = T.unsafe(nil)); end
522
- def lambda?; end
523
- def lambda_literal?; end
524
- def macro?; end
525
- def method_name; end
526
- def non_bare_access_modifier?; end
527
- def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
528
- def receiver; end
529
- def safe_navigation?; end
530
- def self_receiver?; end
531
- def setter_method?; end
532
- def special_modifier?; end
533
- def unary_operation?; end
534
- end
535
-
536
- RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
537
- RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
538
-
539
- module RuboCop::AST::MethodIdentifierPredicates
540
- def assignment_method?; end
541
- def bang_method?; end
542
- def camel_case_method?; end
543
- def comparison_method?; end
544
- def const_receiver?; end
545
- def enumerable_method?; end
546
- def enumerator_method?; end
547
- def method?(name); end
548
- def negation_method?; end
549
- def nonmutating_array_method?; end
550
- def nonmutating_binary_operator_method?; end
551
- def nonmutating_hash_method?; end
552
- def nonmutating_operator_method?; end
553
- def nonmutating_string_method?; end
554
- def nonmutating_unary_operator_method?; end
555
- def operator_method?; end
556
- def predicate_method?; end
557
- def prefix_bang?; end
558
- def prefix_not?; end
559
- def self_receiver?; end
560
- end
561
-
562
- RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)
563
- RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)
564
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)
565
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
566
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)
567
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
568
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)
569
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
570
- RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
571
-
572
- module RuboCop::AST::ModifierNode
573
- def modifier_form?; end
574
- end
575
-
576
- class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
577
- def body; end
578
- def identifier; end
579
- end
580
-
581
- class RuboCop::AST::NextNode < ::RuboCop::AST::Node
582
- include ::RuboCop::AST::ParameterizedNode
583
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
584
- end
585
-
586
- class RuboCop::AST::Node < ::Parser::AST::Node
587
- include ::RuboCop::AST::Sexp
588
- include ::RuboCop::AST::Descendence
589
- include ::RuboCop::RSpec::Node
590
- extend ::RuboCop::AST::NodePattern::Macros
591
-
592
- def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
593
-
594
- def __ENCODING___type?; end
595
- def __FILE___type?; end
596
- def __LINE___type?; end
597
- def alias_type?; end
598
- def ancestors; end
599
- def and_asgn_type?; end
600
- def and_type?; end
601
- def arg_expr_type?; end
602
- def arg_type?; end
603
- def args_type?; end
604
- def argument?; end
605
- def argument_type?; end
606
- def array_pattern_type?; end
607
- def array_pattern_with_tail_type?; end
608
- def array_type?; end
609
- def assignment?; end
610
- def assignment_or_similar?(param0 = T.unsafe(nil)); end
611
- def back_ref_type?; end
612
- def basic_conditional?; end
613
- def basic_literal?; end
614
- def begin_type?; end
615
- def block_pass_type?; end
616
- def block_type?; end
617
- def blockarg_expr_type?; end
618
- def blockarg_type?; end
619
- def boolean_type?; end
620
- def break_type?; end
621
- def call_type?; end
622
- def case_match_type?; end
623
- def case_type?; end
624
- def casgn_type?; end
625
- def cbase_type?; end
626
- def chained?; end
627
- def class_constructor?(param0 = T.unsafe(nil)); end
628
- def class_definition?(param0 = T.unsafe(nil)); end
629
- def class_type?; end
630
- def complete!; end
631
- def complete?; end
632
- def complex_type?; end
633
- def conditional?; end
634
- def const_name; end
635
- def const_pattern_type?; end
636
- def const_type?; end
637
- def csend_type?; end
638
- def cvar_type?; end
639
- def cvasgn_type?; end
640
- def def_type?; end
641
- def defined_module; end
642
- def defined_module_name; end
643
- def defined_type?; end
644
- def defs_type?; end
645
- def dstr_type?; end
646
- def dsym_type?; end
647
- def each_ancestor(*types, &block); end
648
- def eflipflop_type?; end
649
- def empty_else_type?; end
650
- def empty_source?; end
651
- def ensure_type?; end
652
- def equals_asgn?; end
653
- def erange_type?; end
654
- def false_type?; end
655
- def falsey_literal?; end
656
- def find_pattern_type?; end
657
- def first_line; end
658
- def float_type?; end
659
- def for_type?; end
660
- def forward_arg_type?; end
661
- def forward_args_type?; end
662
- def forwarded_args_type?; end
663
- def global_const?(param0 = T.unsafe(nil), param1); end
664
- def guard_clause?; end
665
- def gvar_type?; end
666
- def gvasgn_type?; end
667
- def hash_pattern_type?; end
668
- def hash_type?; end
669
- def ident_type?; end
670
- def if_guard_type?; end
671
- def if_type?; end
672
- def iflipflop_type?; end
673
- def immutable_literal?; end
674
- def in_match_type?; end
675
- def in_pattern_type?; end
676
- def index_type?; end
677
- def indexasgn_type?; end
678
- def int_type?; end
679
- def irange_type?; end
680
- def ivar_type?; end
681
- def ivasgn_type?; end
682
- def keyword?; end
683
- def kwarg_type?; end
684
- def kwargs_type?; end
685
- def kwbegin_type?; end
686
- def kwnilarg_type?; end
687
- def kwoptarg_type?; end
688
- def kwrestarg_type?; end
689
- def kwsplat_type?; end
690
- def lambda?(param0 = T.unsafe(nil)); end
691
- def lambda_or_proc?(param0 = T.unsafe(nil)); end
692
- def lambda_type?; end
693
- def last_line; end
694
- def left_sibling; end
695
- def left_siblings; end
696
- def line_count; end
697
- def literal?; end
698
- def loop_keyword?; end
699
- def lvar_type?; end
700
- def lvasgn_type?; end
701
- def masgn_type?; end
702
- def match_alt_type?; end
703
- def match_as_type?; end
704
- def match_current_line_type?; end
705
- def match_guard_clause?(param0 = T.unsafe(nil)); end
706
- def match_nil_pattern_type?; end
707
- def match_pattern_p_type?; end
708
- def match_pattern_type?; end
709
- def match_rest_type?; end
710
- def match_var_type?; end
711
- def match_with_lvasgn_type?; end
712
- def match_with_trailing_comma_type?; end
713
- def mlhs_type?; end
714
- def module_definition?(param0 = T.unsafe(nil)); end
715
- def module_type?; end
716
- def multiline?; end
717
- def mutable_literal?; end
718
- def new_class_or_module_block?(param0 = T.unsafe(nil)); end
719
- def next_type?; end
720
- def nil_type?; end
721
- def node_parts; end
722
- def nonempty_line_count; end
723
- def not_type?; end
724
- def nth_ref_type?; end
725
- def numargs_type?; end
726
- def numblock_type?; end
727
- def numeric_type?; end
728
- def objc_kwarg_type?; end
729
- def objc_restarg_type?; end
730
- def objc_varargs_type?; end
731
- def op_asgn_type?; end
732
- def operator_keyword?; end
733
- def optarg_type?; end
734
- def or_asgn_type?; end
735
- def or_type?; end
736
- def pair_type?; end
737
- def parent; end
738
- def parent?; end
739
- def parent_module_name; end
740
- def parenthesized_call?; end
741
- def pin_type?; end
742
- def post_condition_loop?; end
743
- def postexe_type?; end
744
- def preexe_type?; end
745
- def proc?(param0 = T.unsafe(nil)); end
746
- def procarg0_type?; end
747
- def pure?; end
748
- def range_type?; end
749
- def rational_type?; end
750
- def receiver(param0 = T.unsafe(nil)); end
751
- def recursive_basic_literal?; end
752
- def recursive_literal?; end
753
- def redo_type?; end
754
- def reference?; end
755
- def regexp_type?; end
756
- def regopt_type?; end
757
- def resbody_type?; end
758
- def rescue_type?; end
759
- def restarg_expr_type?; end
760
- def restarg_type?; end
761
- def retry_type?; end
762
- def return_type?; end
763
- def right_sibling; end
764
- def right_siblings; end
765
- def root?; end
766
- def sclass_type?; end
767
- def self_type?; end
768
- def send_type?; end
769
- def shadowarg_type?; end
770
- def shorthand_asgn?; end
771
- def sibling_index; end
772
- def single_line?; end
773
- def source; end
774
- def source_length; end
775
- def source_range; end
776
- def special_keyword?; end
777
- def splat_type?; end
778
- def str_content(param0 = T.unsafe(nil)); end
779
- def str_type?; end
780
- def struct_constructor?(param0 = T.unsafe(nil)); end
781
- def super_type?; end
782
- def sym_type?; end
783
- def true_type?; end
784
- def truthy_literal?; end
785
- def undef_type?; end
786
- def unless_guard_type?; end
787
- def until_post_type?; end
788
- def until_type?; end
789
- def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
790
- def value_used?; end
791
- def variable?; end
792
- def when_type?; end
793
- def while_post_type?; end
794
- def while_type?; end
795
- def xstr_type?; end
796
- def yield_type?; end
797
- def zsuper_type?; end
798
-
799
- protected
800
-
801
- def parent=(node); end
802
-
803
- private
804
-
805
- def begin_value_used?; end
806
- def case_if_value_used?; end
807
- def defined_module0(param0 = T.unsafe(nil)); end
808
- def for_value_used?; end
809
- def parent_module_name_for_block(ancestor); end
810
- def parent_module_name_for_sclass(sclass_node); end
811
- def parent_module_name_part(node); end
812
- def visit_ancestors(types); end
813
- def while_until_value_used?; end
814
- end
815
-
816
- RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
817
- RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
818
- RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
819
- RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
820
- RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
821
- RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
822
- RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
823
- RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
824
- RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
825
- RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
826
- RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
827
- RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
828
- RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
829
- RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
830
- RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
831
- RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
832
- RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
833
- RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
834
- RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
835
- RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
836
- RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
837
- RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
838
- RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
839
-
840
- class RuboCop::AST::NodePattern
841
- include ::RuboCop::AST::NodePattern::MethodDefiner
842
- extend ::Forwardable
843
-
844
- def initialize(str, compiler: T.unsafe(nil)); end
845
-
846
- def ==(other); end
847
- def as_json(_options = T.unsafe(nil)); end
848
- def ast; end
849
- def captures(*args, &block); end
850
- def encode_with(coder); end
851
- def eql?(other); end
852
- def freeze; end
853
- def init_with(coder); end
854
- def marshal_dump; end
855
- def marshal_load(pattern); end
856
- def match(*args, **rest, &block); end
857
- def match_code; end
858
- def named_parameters(*args, &block); end
859
- def pattern; end
860
- def positional_parameters(*args, &block); end
861
- def to_s; end
862
-
863
- class << self
864
- def descend(element, &block); end
865
- end
866
- end
867
-
868
- class RuboCop::AST::NodePattern::Builder
869
- def emit_atom(type, value); end
870
- def emit_call(type, selector, args = T.unsafe(nil)); end
871
- def emit_capture(capture_token, node); end
872
- def emit_list(type, _begin, children, _end); end
873
- def emit_subsequence(node_list); end
874
- def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
875
- def emit_union(begin_t, pattern_lists, end_t); end
876
-
877
- private
878
-
879
- def n(type, *args); end
880
- def optimizable_as_set?(children); end
881
- def union_children(pattern_lists); end
882
- end
883
-
884
- class RuboCop::AST::NodePattern::Comment
885
- def initialize(range); end
886
-
887
- def ==(other); end
888
- def inspect; end
889
- def loc; end
890
- def location; end
891
- def text; end
892
- end
893
-
894
- class RuboCop::AST::NodePattern::Compiler
895
- extend ::Forwardable
896
-
897
- def initialize; end
898
-
899
- def bind(*args, &block); end
900
- def binding; end
901
- def captures; end
902
- def compile_as_atom(node); end
903
- def compile_as_node_pattern(node, **options); end
904
- def compile_sequence(sequence, var:); end
905
- def each_union(enum, &block); end
906
- def freeze; end
907
- def named_parameter(name); end
908
- def named_parameters; end
909
- def next_capture; end
910
- def parser; end
911
- def positional_parameter(number); end
912
- def positional_parameters; end
913
- def with_temp_variables(*names, &block); end
914
-
915
- private
916
-
917
- def enforce_same_captures(enum); end
918
- def new_capture; end
919
- end
920
-
921
- class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
922
- private
923
-
924
- def visit_const; end
925
- def visit_named_parameter; end
926
- def visit_number; end
927
- def visit_other_type; end
928
- def visit_positional_parameter; end
929
- def visit_regexp; end
930
- def visit_set; end
931
- def visit_string; end
932
- def visit_symbol; end
933
- def visit_unify; end
934
- end
935
-
936
- class RuboCop::AST::NodePattern::Compiler::Binding
937
- def initialize; end
938
-
939
- def bind(name); end
940
- def union_bind(enum); end
941
-
942
- private
943
-
944
- def forbid(names); end
945
- end
946
-
947
- class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
948
- def initialize; end
949
-
950
- def comments(*args, &block); end
951
- def named_parameters; end
952
- def node_ids; end
953
- def parser; end
954
- def tokens(*args, &block); end
955
- end
956
-
957
- class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
958
- def initialize(pattern, compiler: T.unsafe(nil)); end
959
-
960
- def compiler; end
961
- def node_pattern; end
962
- def pattern; end
963
- def test(ruby, trace: T.unsafe(nil)); end
964
-
965
- private
966
-
967
- def ruby_ast(ruby); end
968
- def ruby_parser; end
969
- end
970
-
971
- RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
972
- RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
973
-
974
- class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
975
- def color_map(color_scheme = T.unsafe(nil)); end
976
- def colorize(color_scheme = T.unsafe(nil)); end
977
- def colorizer; end
978
- def colorizer=(_); end
979
- def match_map; end
980
- def matched?(node); end
981
- def returned; end
982
- def returned=(_); end
983
- def ruby_ast; end
984
- def ruby_ast=(_); end
985
- def trace; end
986
- def trace=(_); end
987
-
988
- private
989
-
990
- def ast; end
991
- def color_map_for(node, color); end
992
-
993
- class << self
994
- def [](*_arg0); end
995
- def inspect; end
996
- def members; end
997
- def new(*_arg0); end
998
- end
999
- end
1000
-
1001
- module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1002
- def do_compile; end
1003
-
1004
- private
1005
-
1006
- def node_id; end
1007
- def tracer(kind); end
1008
- end
1009
-
1010
- class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
1011
- include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1012
- end
1013
-
1014
- class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
1015
- include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1016
- end
1017
-
1018
- class RuboCop::AST::NodePattern::Compiler::Debug::Trace
1019
- def initialize; end
1020
-
1021
- def enter(node_id); end
1022
- def matched?(node_id); end
1023
- def success(node_id); end
1024
- end
1025
-
1026
- class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
1027
- def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
1028
-
1029
- def access; end
1030
- def seq_head; end
1031
-
1032
- private
1033
-
1034
- def access_element; end
1035
- def access_node; end
1036
- def compile_args(arg_list, first: T.unsafe(nil)); end
1037
- def compile_guard_clause; end
1038
- def compile_value_match(value); end
1039
- def multiple_access(kind); end
1040
- def visit_ascend; end
1041
- def visit_capture; end
1042
- def visit_descend; end
1043
- def visit_function_call; end
1044
- def visit_intersection; end
1045
- def visit_negation; end
1046
- def visit_node_type; end
1047
- def visit_other_type; end
1048
- def visit_predicate; end
1049
- def visit_sequence; end
1050
- def visit_unify; end
1051
- def visit_union; end
1052
- def visit_wildcard; end
1053
- end
1054
-
1055
- class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
1056
- def initialize(compiler, sequence:, var:); end
1057
-
1058
- def compile_sequence; end
1059
- def in_sync; end
1060
-
1061
- protected
1062
-
1063
- def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
1064
- def cur_index; end
1065
- def sync; end
1066
-
1067
- private
1068
-
1069
- def compile_and_advance(term); end
1070
- def compile_any_order_branches(matched_var); end
1071
- def compile_any_order_else; end
1072
- def compile_captured_repetition(child_code, child_captures); end
1073
- def compile_case(when_branches, else_code); end
1074
- def compile_child_nb_guard(arity_range); end
1075
- def compile_cur_index; end
1076
- def compile_index(cur = T.unsafe(nil)); end
1077
- def compile_loop(term); end
1078
- def compile_loop_advance(to = T.unsafe(nil)); end
1079
- def compile_matched(kind); end
1080
- def compile_max_matched; end
1081
- def compile_min_check; end
1082
- def compile_remaining; end
1083
- def compile_union_forks; end
1084
- def empty_loop; end
1085
- def handle_prev; end
1086
- def merge_forks!(forks); end
1087
- def preserve_union_start(forks); end
1088
- def remaining_arities(children, last_arity); end
1089
- def use_index_from_end; end
1090
- def visit_any_order; end
1091
- def visit_capture; end
1092
- def visit_other_type; end
1093
- def visit_repetition; end
1094
- def visit_rest; end
1095
- def visit_union; end
1096
- def within_loop; end
1097
- end
1098
-
1099
- RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
1100
- RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
1101
-
1102
- class RuboCop::AST::NodePattern::Compiler::Subcompiler
1103
- def initialize(compiler); end
1104
-
1105
- def compile(node); end
1106
- def compiler; end
1107
-
1108
- private
1109
-
1110
- def do_compile; end
1111
- def node; end
1112
-
1113
- class << self
1114
- def inherited(base); end
1115
- def method_added(method); end
1116
- def registry; end
1117
- end
1118
- end
1119
-
1120
- class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
1121
-
1122
- class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
1123
- def initialize(source); end
1124
-
1125
- def comments; end
1126
- def source_buffer; end
1127
- def tokens; end
1128
-
1129
- private
1130
-
1131
- def do_parse; end
1132
- def emit(type); end
1133
- def emit_comment; end
1134
- def emit_regexp; end
1135
- def token(type, value); end
1136
- end
1137
-
1138
- RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
1139
- RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
1140
-
1141
- class RuboCop::AST::NodePattern::LexerRex
1142
- def action; end
1143
- def filename; end
1144
- def filename=(_arg0); end
1145
- def location; end
1146
- def match; end
1147
- def matches; end
1148
- def next_token; end
1149
- def parse(str); end
1150
- def parse_file(path); end
1151
- def scanner_class; end
1152
- def ss; end
1153
- def ss=(_arg0); end
1154
- def state; end
1155
- def state=(_arg0); end
1156
- end
1157
-
1158
- RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
1159
- RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
1160
- RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
1161
- class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
1162
- RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
1163
- RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
1164
- RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
1165
- RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
1166
- class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end
1167
-
1168
- module RuboCop::AST::NodePattern::Macros
1169
- def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
1170
- def def_node_search(method_name, pattern_str, **keyword_defaults); end
1171
- end
1172
-
1173
- module RuboCop::AST::NodePattern::MethodDefiner
1174
- def as_lambda; end
1175
- def compile_as_lambda; end
1176
- def def_node_matcher(base, method_name, **defaults); end
1177
- def def_node_search(base, method_name, **defaults); end
1178
-
1179
- private
1180
-
1181
- def compile_init; end
1182
- def def_helper(base, method_name, **defaults); end
1183
- def emit_keyword_list(forwarding: T.unsafe(nil)); end
1184
- def emit_lambda_code; end
1185
- def emit_method_code; end
1186
- def emit_node_search(method_name); end
1187
- def emit_node_search_body(method_name, prelude:, on_match:); end
1188
- def emit_param_list; end
1189
- def emit_params(*first, forwarding: T.unsafe(nil)); end
1190
- def emit_retval; end
1191
- def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
1192
- def wrapping_block(method_name, **defaults); end
1193
- end
1194
-
1195
- class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
1196
- include ::RuboCop::AST::Descendence
1197
- extend ::Forwardable
1198
-
1199
- def arity; end
1200
- def arity_range; end
1201
- def capture?; end
1202
- def child; end
1203
- def children_nodes; end
1204
- def in_sequence_head; end
1205
- def matches_within_set?; end
1206
- def nb_captures; end
1207
- def rest?; end
1208
- def variadic?; end
1209
- def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
1210
- end
1211
-
1212
- class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
1213
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1214
-
1215
- def arity; end
1216
- def ends_with_rest?; end
1217
- def rest_node; end
1218
- def term_nodes; end
1219
- end
1220
-
1221
- RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
1222
-
1223
- class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
1224
- def arity(*args, &block); end
1225
- def capture?; end
1226
- def in_sequence_head; end
1227
- def nb_captures; end
1228
- def rest?(*args, &block); end
1229
- end
1230
-
1231
- module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1232
- def in_sequence_head; end
1233
- end
1234
-
1235
- RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
1236
- RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
1237
- RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
1238
- RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
1239
-
1240
- class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
1241
- def arg_list; end
1242
- def method_name; end
1243
- end
1244
-
1245
- class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
1246
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1247
-
1248
- def arity; end
1249
- def operator; end
1250
- end
1251
-
1252
- RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
1253
-
1254
- class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
1255
- def arity; end
1256
- def in_sequence_head; end
1257
- def rest?; end
1258
- end
1259
-
1260
- RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
1261
-
1262
- class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
1263
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1264
-
1265
- def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
1266
- end
1267
-
1268
- class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
1269
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1270
-
1271
- def arity; end
1272
- def in_sequence_head; end
1273
- end
1274
-
1275
- class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
1276
- def arity; end
1277
- def in_sequence_head; end
1278
- end
1279
-
1280
- class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
1281
- extend ::Forwardable
1282
-
1283
- def initialize(builder = T.unsafe(nil)); end
1284
-
1285
- def _reduce_10(val, _values); end
1286
- def _reduce_11(val, _values); end
1287
- def _reduce_13(val, _values); end
1288
- def _reduce_14(val, _values); end
1289
- def _reduce_15(val, _values); end
1290
- def _reduce_16(val, _values); end
1291
- def _reduce_17(val, _values); end
1292
- def _reduce_18(val, _values); end
1293
- def _reduce_19(val, _values); end
1294
- def _reduce_2(val, _values); end
1295
- def _reduce_20(val, _values); end
1296
- def _reduce_21(val, _values); end
1297
- def _reduce_22(val, _values); end
1298
- def _reduce_25(val, _values); end
1299
- def _reduce_26(val, _values); end
1300
- def _reduce_3(val, _values); end
1301
- def _reduce_33(val, _values); end
1302
- def _reduce_37(val, _values); end
1303
- def _reduce_38(val, _values); end
1304
- def _reduce_39(val, _values); end
1305
- def _reduce_4(val, _values); end
1306
- def _reduce_40(val, _values); end
1307
- def _reduce_41(val, _values); end
1308
- def _reduce_42(val, _values); end
1309
- def _reduce_43(val, _values); end
1310
- def _reduce_44(val, _values); end
1311
- def _reduce_45(val, _values); end
1312
- def _reduce_46(val, _values); end
1313
- def _reduce_5(val, _values); end
1314
- def _reduce_6(val, _values); end
1315
- def _reduce_7(val, _values); end
1316
- def _reduce_8(val, _values); end
1317
- def _reduce_9(val, _values); end
1318
- def _reduce_none(val, _values); end
1319
- def emit_atom(*args, &block); end
1320
- def emit_call(*args, &block); end
1321
- def emit_capture(*args, &block); end
1322
- def emit_list(*args, &block); end
1323
- def emit_unary_op(*args, &block); end
1324
- def emit_union(*args, &block); end
1325
- def inspect; end
1326
- def next_token(*args, &block); end
1327
- def parse(source); end
1328
-
1329
- private
1330
-
1331
- def enforce_unary(node); end
1332
- def on_error(token, val, _vstack); end
1333
- end
1334
-
1335
- RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
1336
- RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
1337
- RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
1338
- RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
1339
-
1340
- class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
1341
- def comments; end
1342
- def do_parse; end
1343
- def tokens; end
1344
- end
1345
-
1346
- class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
1347
- def emit_atom(type, token); end
1348
- def emit_call(type, selector_t, args = T.unsafe(nil)); end
1349
- def emit_list(type, begin_t, children, end_t); end
1350
- def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
1351
-
1352
- private
1353
-
1354
- def join_exprs(left_expr, right_expr); end
1355
- def loc(token_or_range); end
1356
- def n(type, children, source_map); end
1357
- def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
1358
- end
1359
-
1360
- class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
1361
- def initialize(str_or_buffer); end
1362
-
1363
- def emit_comment; end
1364
- def pos; end
1365
- def source_buffer; end
1366
- def token(type, value); end
1367
- end
1368
-
1369
- module RuboCop::AST::NodePattern::Sets
1370
- class << self
1371
- def [](set); end
1372
- def name(set); end
1373
- def uniq(name); end
1374
- end
1375
- end
1376
-
1377
- RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
1378
- RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
1379
- RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
1380
- RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
1381
- RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
1382
- RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set)
1383
- RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
1384
- RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set)
1385
- RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set)
1386
- RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
1387
- RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set)
1388
- RuboCop::AST::NodePattern::Sets::SET_BEFORE_AFTER = T.let(T.unsafe(nil), Set)
1389
- RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set)
1390
- RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set)
1391
- RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
1392
- RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set)
1393
- RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
1394
- RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
1395
- RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
1396
- RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
1397
- RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
1398
- RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
1399
- RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
1400
- RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
1401
- RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set)
1402
- RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
1403
- RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_FEATURE = T.let(T.unsafe(nil), Set)
1404
- RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set)
1405
- RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set)
1406
- RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
1407
- RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
1408
- RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set)
1409
- RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set)
1410
- RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
1411
- RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set)
1412
- RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set)
1413
- RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set)
1414
- RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
1415
- RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
1416
- RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
1417
- RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
1418
- RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
1419
- RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
1420
- RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
1421
- RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
1422
- RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
1423
- RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
1424
- RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
1425
- RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
1426
- RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
1427
- RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
1428
- RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set)
1429
- RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
1430
- RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
1431
- RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
1432
- RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set)
1433
- RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
1434
- RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set)
1435
- RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
1436
- RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
1437
- RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set)
1438
- RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
1439
- RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
1440
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
1441
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set)
1442
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
1443
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set)
1444
- RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
1445
- RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
1446
- RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
1447
- RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set)
1448
- RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
1449
- RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
1450
- RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set)
1451
- RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
1452
- RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
1453
- RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
1454
- RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
1455
- RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
1456
- RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
1457
- RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
1458
- RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set)
1459
- RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C = T.let(T.unsafe(nil), Set)
1460
- RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
1461
- RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
1462
- RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
1463
- RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
1464
- RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
1465
- RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
1466
- RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
1467
- RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
1468
- RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
1469
- RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
1470
- RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
1471
- RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
1472
- RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
1473
- RuboCop::AST::NodePattern::Sets::SET___EQL = T.let(T.unsafe(nil), Set)
1474
- RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
1475
- RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
1476
- RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
1477
- RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
1478
- RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
1479
- RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
1480
-
1481
- module RuboCop::AST::NumericNode
1482
- def sign?; end
1483
- end
1484
-
1485
- RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)
1486
-
1487
- class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node
1488
- def assignment_node; end
1489
- def expression; end
1490
- def name; end
1491
- def operator; end
1492
- end
1493
-
1494
- class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode
1495
- def operator; end
1496
- end
1497
-
1498
- class RuboCop::AST::OrNode < ::RuboCop::AST::Node
1499
- include ::RuboCop::AST::BinaryOperatorNode
1500
- include ::RuboCop::AST::PredicateOperatorNode
1501
-
1502
- def alternate_operator; end
1503
- def inverse_operator; end
1504
- end
1505
-
1506
- class RuboCop::AST::PairNode < ::RuboCop::AST::Node
1507
- include ::RuboCop::AST::HashElementNode
1508
-
1509
- def colon?; end
1510
- def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
1511
- def hash_rocket?; end
1512
- def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
1513
- def value_on_new_line?; end
1514
- end
1515
-
1516
- RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)
1517
- RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)
1518
- RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)
1519
- RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)
1520
-
1521
- module RuboCop::AST::ParameterizedNode
1522
- def arguments?; end
1523
- def block_argument?; end
1524
- def first_argument; end
1525
- def last_argument; end
1526
- def parenthesized?; end
1527
- def rest_argument?; end
1528
- def splat_argument?; end
1529
- end
1530
-
1531
- module RuboCop::AST::ParameterizedNode::RestArguments
1532
- include ::RuboCop::AST::ParameterizedNode
1533
-
1534
- def arguments; end
1535
- def arguments?; end
1536
- def first_argument; end
1537
- def last_argument; end
1538
- end
1539
-
1540
- module RuboCop::AST::ParameterizedNode::WrappedArguments
1541
- include ::RuboCop::AST::ParameterizedNode
1542
-
1543
- def arguments; end
1544
- end
1545
-
1546
- module RuboCop::AST::PredicateOperatorNode
1547
- def logical_operator?; end
1548
- def operator; end
1549
- def semantic_operator?; end
1550
- end
1551
-
1552
- RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
1553
- RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
1554
- RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
1555
- RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
1556
-
1557
- class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode
1558
- def name; end
1559
- end
1560
-
1561
- class RuboCop::AST::ProcessedSource
1562
- include ::RuboCop::Ext::ProcessedSource
1563
-
1564
- def initialize(source, ruby_version, path = T.unsafe(nil)); end
1565
-
1566
- def [](*args); end
1567
- def ast; end
1568
- def ast_with_comments; end
1569
- def blank?; end
1570
- def buffer; end
1571
- def checksum; end
1572
- def comment_at_line(line); end
1573
- def commented?(source_range); end
1574
- def comments; end
1575
- def comments_before_line(line); end
1576
- def contains_comment?(source_range); end
1577
- def current_line(token); end
1578
- def diagnostics; end
1579
- def each_comment(&block); end
1580
- def each_comment_in_lines(line_range); end
1581
- def each_token(&block); end
1582
- def file_path; end
1583
- def find_comment(&block); end
1584
- def find_token(&block); end
1585
- def first_token_of(range_or_node); end
1586
- def following_line(token); end
1587
- def last_token_of(range_or_node); end
1588
- def line_indentation(line_number); end
1589
- def line_with_comment?(line); end
1590
- def lines; end
1591
- def parser_error; end
1592
- def path; end
1593
- def preceding_line(token); end
1594
- def raw_source; end
1595
- def ruby_version; end
1596
- def sorted_tokens; end
1597
- def start_with?(string); end
1598
- def tokens; end
1599
- def tokens_within(range_or_node); end
1600
- def valid_syntax?; end
1601
-
1602
- private
1603
-
1604
- def comment_index; end
1605
- def create_parser(ruby_version); end
1606
- def first_token_index(range_or_node); end
1607
- def last_token_index(range_or_node); end
1608
- def parse(source, ruby_version); end
1609
- def parser_class(ruby_version); end
1610
- def source_range(range_or_node); end
1611
- def tokenize(parser); end
1612
-
1613
- class << self
1614
- def from_file(path, ruby_version); end
1615
- end
1616
- end
1617
-
1618
- RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
1619
- RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
1620
-
1621
- class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
1622
- def begin; end
1623
- def end; end
1624
- end
1625
-
1626
- class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
1627
- include ::RuboCop::Ext::RegexpNode
1628
-
1629
- def content; end
1630
- def delimiter?(char); end
1631
- def delimiters; end
1632
- def extended?; end
1633
- def ignore_case?; end
1634
- def interpolation?; end
1635
- def multiline_mode?; end
1636
- def no_encoding?; end
1637
- def options; end
1638
- def percent_r_literal?; end
1639
- def regopt; end
1640
- def single_interpolation?; end
1641
- def slash_literal?; end
1642
- def to_regexp; end
1643
-
1644
- private
1645
-
1646
- def regopt_include?(option); end
1647
- end
1648
-
1649
- RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)
1650
-
1651
- class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
1652
- def body; end
1653
- def branch_index; end
1654
- def exception_variable; end
1655
- def exceptions; end
1656
- end
1657
-
1658
- class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
1659
- def body; end
1660
- def branches; end
1661
- def else?; end
1662
- def else_branch; end
1663
- def resbody_branches; end
1664
- end
1665
-
1666
- class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
1667
- include ::RuboCop::AST::ParameterizedNode
1668
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
1669
- end
1670
-
1671
- module RuboCop::AST::RuboCopCompatibility
1672
- def rubocop_loaded; end
1673
- end
1674
-
1675
- RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
1676
-
1677
- class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
1678
- def body; end
1679
- def identifier; end
1680
- end
1681
-
1682
- class RuboCop::AST::SendNode < ::RuboCop::AST::Node
1683
- include ::RuboCop::AST::ParameterizedNode
1684
- include ::RuboCop::AST::ParameterizedNode::RestArguments
1685
- include ::RuboCop::AST::MethodIdentifierPredicates
1686
- include ::RuboCop::AST::MethodDispatchNode
1687
-
1688
- def attribute_accessor?(param0 = T.unsafe(nil)); end
1689
-
1690
- private
1691
-
1692
- def first_argument_index; end
1693
- end
1694
-
1695
- module RuboCop::AST::Sexp
1696
- def s(type, *children); end
1697
- end
1698
-
1699
- class RuboCop::AST::StrNode < ::RuboCop::AST::Node
1700
- include ::RuboCop::AST::BasicLiteralNode
1701
-
1702
- def heredoc?; end
1703
- end
1704
-
1705
- class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
1706
- include ::RuboCop::AST::ParameterizedNode
1707
- include ::RuboCop::AST::MethodIdentifierPredicates
1708
- include ::RuboCop::AST::MethodDispatchNode
1709
-
1710
- def arguments; end
1711
- def node_parts; end
1712
- end
1713
-
1714
- class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
1715
- include ::RuboCop::AST::BasicLiteralNode
1716
- end
1717
-
1718
- class RuboCop::AST::Token
1719
- def initialize(pos, type, text); end
1720
-
1721
- def begin_pos; end
1722
- def column; end
1723
- def comma?; end
1724
- def comment?; end
1725
- def end?; end
1726
- def end_pos; end
1727
- def equal_sign?; end
1728
- def left_array_bracket?; end
1729
- def left_brace?; end
1730
- def left_bracket?; end
1731
- def left_curly_brace?; end
1732
- def left_parens?; end
1733
- def left_ref_bracket?; end
1734
- def line; end
1735
- def pos; end
1736
- def rescue_modifier?; end
1737
- def right_bracket?; end
1738
- def right_curly_brace?; end
1739
- def right_parens?; end
1740
- def semicolon?; end
1741
- def space_after?; end
1742
- def space_before?; end
1743
- def text; end
1744
- def to_s; end
1745
- def type; end
1746
-
1747
- class << self
1748
- def from_parser_token(parser_token); end
1749
- end
1750
- end
1751
-
1752
- module RuboCop::AST::Traversal
1753
- extend ::RuboCop::AST::Traversal::CallbackCompiler
1754
-
1755
- def on_(node); end
1756
- def on___ENCODING__(node); end
1757
- def on___FILE__(node); end
1758
- def on___LINE__(node); end
1759
- def on_alias(node); end
1760
- def on_and(node); end
1761
- def on_and_asgn(node); end
1762
- def on_arg(node); end
1763
- def on_arg_expr(node); end
1764
- def on_args(node); end
1765
- def on_array(node); end
1766
- def on_array_pattern(node); end
1767
- def on_array_pattern_with_tail(node); end
1768
- def on_back_ref(node); end
1769
- def on_begin(node); end
1770
- def on_block(node); end
1771
- def on_block_pass(node); end
1772
- def on_blockarg(node); end
1773
- def on_break(node); end
1774
- def on_case(node); end
1775
- def on_case_match(node); end
1776
- def on_casgn(node); end
1777
- def on_cbase(node); end
1778
- def on_class(node); end
1779
- def on_complex(node); end
1780
- def on_const(node); end
1781
- def on_const_pattern(node); end
1782
- def on_csend(node); end
1783
- def on_cvar(node); end
1784
- def on_cvasgn(node); end
1785
- def on_def(node); end
1786
- def on_defined?(node); end
1787
- def on_defs(node); end
1788
- def on_dstr(node); end
1789
- def on_dsym(node); end
1790
- def on_eflipflop(node); end
1791
- def on_empty_else(node); end
1792
- def on_ensure(node); end
1793
- def on_erange(node); end
1794
- def on_false(node); end
1795
- def on_find_pattern(node); end
1796
- def on_float(node); end
1797
- def on_for(node); end
1798
- def on_forward_arg(node); end
1799
- def on_forward_args(node); end
1800
- def on_forwarded_args(node); end
1801
- def on_gvar(node); end
1802
- def on_gvasgn(node); end
1803
- def on_hash(node); end
1804
- def on_hash_pattern(node); end
1805
- def on_if(node); end
1806
- def on_if_guard(node); end
1807
- def on_iflipflop(node); end
1808
- def on_in_match(node); end
1809
- def on_in_pattern(node); end
1810
- def on_index(node); end
1811
- def on_indexasgn(node); end
1812
- def on_int(node); end
1813
- def on_irange(node); end
1814
- def on_ivar(node); end
1815
- def on_ivasgn(node); end
1816
- def on_kwarg(node); end
1817
- def on_kwargs(node); end
1818
- def on_kwbegin(node); end
1819
- def on_kwnilarg(node); end
1820
- def on_kwoptarg(node); end
1821
- def on_kwrestarg(node); end
1822
- def on_kwsplat(node); end
1823
- def on_lambda(node); end
1824
- def on_lvar(node); end
1825
- def on_lvasgn(node); end
1826
- def on_masgn(node); end
1827
- def on_match_alt(node); end
1828
- def on_match_as(node); end
1829
- def on_match_current_line(node); end
1830
- def on_match_nil_pattern(node); end
1831
- def on_match_pattern(node); end
1832
- def on_match_pattern_p(node); end
1833
- def on_match_rest(node); end
1834
- def on_match_var(node); end
1835
- def on_match_with_lvasgn(node); end
1836
- def on_match_with_trailing_comma(node); end
1837
- def on_mlhs(node); end
1838
- def on_module(node); end
1839
- def on_mrasgn(node); end
1840
- def on_next(node); end
1841
- def on_nil(node); end
1842
- def on_not(node); end
1843
- def on_nth_ref(node); end
1844
- def on_numblock(node); end
1845
- def on_op_asgn(node); end
1846
- def on_optarg(node); end
1847
- def on_or(node); end
1848
- def on_or_asgn(node); end
1849
- def on_pair(node); end
1850
- def on_pin(node); end
1851
- def on_postexe(node); end
1852
- def on_preexe(node); end
1853
- def on_procarg0(node); end
1854
- def on_rasgn(node); end
1855
- def on_rational(node); end
1856
- def on_redo(node); end
1857
- def on_regexp(node); end
1858
- def on_regopt(node); end
1859
- def on_resbody(node); end
1860
- def on_rescue(node); end
1861
- def on_restarg(node); end
1862
- def on_retry(node); end
1863
- def on_return(node); end
1864
- def on_sclass(node); end
1865
- def on_self(node); end
1866
- def on_send(node); end
1867
- def on_shadowarg(node); end
1868
- def on_splat(node); end
1869
- def on_str(node); end
1870
- def on_super(node); end
1871
- def on_sym(node); end
1872
- def on_true(node); end
1873
- def on_undef(node); end
1874
- def on_unless_guard(node); end
1875
- def on_until(node); end
1876
- def on_until_post(node); end
1877
- def on_when(node); end
1878
- def on_while(node); end
1879
- def on_while_post(node); end
1880
- def on_xstr(node); end
1881
- def on_yield(node); end
1882
- def on_zsuper(node); end
1883
- def walk(node); end
1884
- end
1885
-
1886
- module RuboCop::AST::Traversal::CallbackCompiler
1887
- def arity_check(range); end
1888
- def body(signature, prelude); end
1889
- def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
1890
- end
1891
-
1892
- RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
1893
- RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
1894
- class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
1895
- RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
1896
- RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
1897
-
1898
- class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
1899
- include ::RuboCop::AST::ConditionalNode
1900
- include ::RuboCop::AST::ModifierNode
1901
-
1902
- def do?; end
1903
- def inverse_keyword; end
1904
- def keyword; end
1905
- end
1906
-
1907
- module RuboCop::AST::Version; end
1908
- RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)
1909
-
1910
- class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
1911
- def body; end
1912
- def branch_index; end
1913
- def conditions; end
1914
- def each_condition(&block); end
1915
- def then?; end
1916
- end
1917
-
1918
- class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
1919
- include ::RuboCop::AST::ConditionalNode
1920
- include ::RuboCop::AST::ModifierNode
1921
-
1922
- def do?; end
1923
- def inverse_keyword; end
1924
- def keyword; end
1925
- end
1926
-
1927
- class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
1928
- include ::RuboCop::AST::ParameterizedNode
1929
- include ::RuboCop::AST::MethodIdentifierPredicates
1930
- include ::RuboCop::AST::MethodDispatchNode
1931
-
1932
- def arguments; end
1933
- def node_parts; end
1934
- end
1935
-
1936
- RuboCop::NodePattern = RuboCop::AST::NodePattern
1937
- RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
1938
- RuboCop::Token = RuboCop::AST::Token