thread_weaver 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. checksums.yaml +7 -0
  2. data/.github/workflows/main.yml +19 -0
  3. data/.gitignore +59 -0
  4. data/.rspec +3 -0
  5. data/.vscode/settings.json +14 -0
  6. data/CHANGELOG.md +7 -0
  7. data/Gemfile +17 -0
  8. data/LICENSE +21 -0
  9. data/README.md +37 -0
  10. data/Rakefile +13 -0
  11. data/bin/console +15 -0
  12. data/bin/gem_smoke_test +10 -0
  13. data/bin/setup +8 -0
  14. data/examples/always_deadlocks.rb +15 -0
  15. data/examples/takes_a_while.rb +7 -0
  16. data/examples/thread_safe_nonblocking_run_at_most_once.rb +23 -0
  17. data/examples/thread_safe_run_at_most_once.rb +19 -0
  18. data/examples/thread_unsafe_run_at_most_once.rb +17 -0
  19. data/lib/thread_weaver.rb +15 -0
  20. data/lib/thread_weaver/controllable_thread.rb +177 -0
  21. data/lib/thread_weaver/iterative_race_detector.rb +178 -0
  22. data/lib/thread_weaver/thread_instruction.rb +68 -0
  23. data/lib/thread_weaver/version.rb +6 -0
  24. data/sorbet/config +2 -0
  25. data/sorbet/rbi/gems/ast.rbi +48 -0
  26. data/sorbet/rbi/gems/coderay.rbi +285 -0
  27. data/sorbet/rbi/gems/method_source.rbi +64 -0
  28. data/sorbet/rbi/gems/parallel.rbi +83 -0
  29. data/sorbet/rbi/gems/parser.rbi +1510 -0
  30. data/sorbet/rbi/gems/pry-nav.rbi +29 -0
  31. data/sorbet/rbi/gems/pry.rbi +1965 -0
  32. data/sorbet/rbi/gems/rainbow.rbi +118 -0
  33. data/sorbet/rbi/gems/rake.rbi +645 -0
  34. data/sorbet/rbi/gems/regexp_parser.rbi +920 -0
  35. data/sorbet/rbi/gems/rexml.rbi +589 -0
  36. data/sorbet/rbi/gems/rspec-core.rbi +1893 -0
  37. data/sorbet/rbi/gems/rspec-expectations.rbi +1148 -0
  38. data/sorbet/rbi/gems/rspec-mocks.rbi +1091 -0
  39. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  40. data/sorbet/rbi/gems/rspec.rbi +15 -0
  41. data/sorbet/rbi/gems/rubocop-ast.rbi +1351 -0
  42. data/sorbet/rbi/gems/rubocop-performance.rbi +471 -0
  43. data/sorbet/rbi/gems/rubocop.rbi +7510 -0
  44. data/sorbet/rbi/gems/ruby-progressbar.rbi +305 -0
  45. data/sorbet/rbi/gems/standard.rbi +141 -0
  46. data/sorbet/rbi/gems/unicode-display_width.rbi +17 -0
  47. data/sorbet/rbi/hidden-definitions/errors.txt +4309 -0
  48. data/sorbet/rbi/hidden-definitions/hidden.rbi +8622 -0
  49. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  50. data/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi +149 -0
  51. data/sorbet/rbi/todo.rbi +6 -0
  52. data/thread_weaver.gemspec +34 -0
  53. metadata +111 -0
@@ -0,0 +1,471 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strict
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-performance/all/rubocop-performance.rbi
9
+ #
10
+ # rubocop-performance-1.9.1
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::Performance
15
+ end
16
+ module RuboCop::Performance::Version
17
+ def self.document_version; end
18
+ end
19
+ module RuboCop::Performance::Inject
20
+ def self.defaults!; end
21
+ end
22
+ module RuboCop::Cop
23
+ end
24
+ module RuboCop::Cop::RegexpMetacharacter
25
+ def drop_end_metacharacter(regexp_string); end
26
+ def drop_start_metacharacter(regexp_string); end
27
+ def literal_at_end?(regexp); end
28
+ def literal_at_end_with_backslash_z?(regex_str); end
29
+ def literal_at_end_with_dollar?(regex_str); end
30
+ def literal_at_start?(regexp); end
31
+ def literal_at_start_with_backslash_a?(regex_str); end
32
+ def literal_at_start_with_caret?(regex_str); end
33
+ def safe_multiline?; end
34
+ end
35
+ module RuboCop::Cop::SortBlock
36
+ def replaceable_body?(param0 = nil, param1, param2); end
37
+ def sort_range(send, node); end
38
+ def sort_with_block?(param0 = nil); end
39
+ extend RuboCop::AST::NodePattern::Macros
40
+ include RuboCop::Cop::RangeHelp
41
+ end
42
+ module RuboCop::Cop::Performance
43
+ end
44
+ class RuboCop::Cop::Performance::AncestorsInclude < RuboCop::Cop::Base
45
+ def ancestors_include_candidate?(param0 = nil); end
46
+ def on_send(node); end
47
+ def range(node); end
48
+ extend RuboCop::Cop::AutoCorrector
49
+ include RuboCop::Cop::RangeHelp
50
+ end
51
+ class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice < RuboCop::Cop::Base
52
+ def correction(receiver, range_node); end
53
+ def endless_range?(param0 = nil); end
54
+ def endless_range_slice?(param0 = nil); end
55
+ def on_send(node); end
56
+ extend RuboCop::Cop::AutoCorrector
57
+ extend RuboCop::Cop::TargetRubyVersion
58
+ include RuboCop::Cop::RangeHelp
59
+ end
60
+ class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < RuboCop::Cop::Base
61
+ def big_decimal_with_numeric_argument?(param0 = nil); end
62
+ def on_send(node); end
63
+ def specifies_precision?(node); end
64
+ extend RuboCop::Cop::AutoCorrector
65
+ end
66
+ class RuboCop::Cop::Performance::BindCall < RuboCop::Cop::Base
67
+ def bind_with_call_method?(param0 = nil); end
68
+ def build_call_args(call_args_node); end
69
+ def correction_range(receiver, node); end
70
+ def message(bind_arg, call_args); end
71
+ def on_send(node); end
72
+ extend RuboCop::Cop::AutoCorrector
73
+ extend RuboCop::Cop::TargetRubyVersion
74
+ include RuboCop::Cop::RangeHelp
75
+ end
76
+ class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock < RuboCop::Cop::Base
77
+ def on_send(node); end
78
+ def reassigns_block_arg?(param0 = nil, param1); end
79
+ extend RuboCop::Cop::AutoCorrector
80
+ end
81
+ class RuboCop::Cop::Performance::Caller < RuboCop::Cop::Base
82
+ def caller_with_scope_method?(param0 = nil); end
83
+ def int_value(node); end
84
+ def on_send(node); end
85
+ def slow_caller?(param0 = nil); end
86
+ extend RuboCop::Cop::AutoCorrector
87
+ end
88
+ class RuboCop::Cop::Performance::CaseWhenSplat < RuboCop::Cop::Base
89
+ def autocorrect(corrector, when_node); end
90
+ def indent_for(node); end
91
+ def inline_fix_branch(corrector, when_node); end
92
+ def needs_reorder?(when_node); end
93
+ def new_branch_without_then(node, new_condition); end
94
+ def new_condition_with_then(node, new_condition); end
95
+ def non_splat?(condition); end
96
+ def on_case(case_node); end
97
+ def range(node); end
98
+ def reorder_condition(corrector, when_node); end
99
+ def reordering_correction(when_node); end
100
+ def replacement(conditions); end
101
+ def splat_offenses(when_conditions); end
102
+ def when_branch_range(when_node); end
103
+ extend RuboCop::Cop::AutoCorrector
104
+ include RuboCop::Cop::Alignment
105
+ include RuboCop::Cop::RangeHelp
106
+ end
107
+ class RuboCop::Cop::Performance::Casecmp < RuboCop::Cop::Base
108
+ def build_good_method(arg, variable); end
109
+ def correction(corrector, node, method, arg, variable); end
110
+ def downcase_downcase(param0 = nil); end
111
+ def downcase_eq(param0 = nil); end
112
+ def eq_downcase(param0 = nil); end
113
+ def on_send(node); end
114
+ def take_method_apart(node); end
115
+ extend RuboCop::Cop::AutoCorrector
116
+ end
117
+ class RuboCop::Cop::Performance::CollectionLiteralInLoop < RuboCop::Cop::Base
118
+ def check_literal?(node, method); end
119
+ def enumerable_loop?(param0 = nil); end
120
+ def enumerable_method?(method_name); end
121
+ def kernel_loop?(param0 = nil); end
122
+ def keyword_loop?(type); end
123
+ def literal_class(node); end
124
+ def loop?(ancestor, node); end
125
+ def min_size; end
126
+ def node_within_enumerable_loop?(node, ancestor); end
127
+ def nonmutable_method_of_array_or_hash?(node, method); end
128
+ def on_send(node); end
129
+ def parent_is_loop?(node); end
130
+ end
131
+ class RuboCop::Cop::Performance::CompareWithBlock < RuboCop::Cop::Base
132
+ def compare?(param0 = nil); end
133
+ def compare_range(send, node); end
134
+ def message(send, method, var_a, var_b, args); end
135
+ def on_block(node); end
136
+ def replaceable_body?(param0 = nil, param1, param2); end
137
+ def slow_compare?(method, args_a, args_b); end
138
+ extend RuboCop::Cop::AutoCorrector
139
+ include RuboCop::Cop::RangeHelp
140
+ end
141
+ class RuboCop::Cop::Performance::ConstantRegexp < RuboCop::Cop::Base
142
+ def include_interpolated_const?(node); end
143
+ def on_regexp(node); end
144
+ def regexp_escape?(param0 = nil); end
145
+ def within_const_assignment?(node); end
146
+ extend RuboCop::Cop::AutoCorrector
147
+ end
148
+ class RuboCop::Cop::Performance::Count < RuboCop::Cop::Base
149
+ def autocorrect(corrector, node, selector_node, selector); end
150
+ def count_candidate?(param0 = nil); end
151
+ def eligible_node?(node); end
152
+ def on_send(node); end
153
+ def source_starting_at(node); end
154
+ extend RuboCop::Cop::AutoCorrector
155
+ include RuboCop::Cop::RangeHelp
156
+ end
157
+ class RuboCop::Cop::Performance::DeletePrefix < RuboCop::Cop::Base
158
+ def delete_prefix_candidate?(param0 = nil); end
159
+ def on_send(node); end
160
+ extend RuboCop::Cop::AutoCorrector
161
+ extend RuboCop::Cop::TargetRubyVersion
162
+ include RuboCop::Cop::RegexpMetacharacter
163
+ end
164
+ class RuboCop::Cop::Performance::DeleteSuffix < RuboCop::Cop::Base
165
+ def delete_suffix_candidate?(param0 = nil); end
166
+ def on_send(node); end
167
+ extend RuboCop::Cop::AutoCorrector
168
+ extend RuboCop::Cop::TargetRubyVersion
169
+ include RuboCop::Cop::RegexpMetacharacter
170
+ end
171
+ class RuboCop::Cop::Performance::Detect < RuboCop::Cop::Base
172
+ def accept_first_call?(receiver, body); end
173
+ def autocorrect(corrector, node, replacement); end
174
+ def detect_candidate?(param0 = nil); end
175
+ def lazy?(node); end
176
+ def message_for_method(method, index); end
177
+ def on_send(node); end
178
+ def preferred_method; end
179
+ def register_offense(node, receiver, second_method, index); end
180
+ def replacement(method, index); end
181
+ extend RuboCop::Cop::AutoCorrector
182
+ end
183
+ class RuboCop::Cop::Performance::DoubleStartEndWith < RuboCop::Cop::Base
184
+ def autocorrect(corrector, first_call_args, second_call_args, combined_args); end
185
+ def check_for_active_support_aliases?; end
186
+ def check_with_active_support_aliases(param0 = nil); end
187
+ def combine_args(first_call_args, second_call_args); end
188
+ def message(node, receiver, method, combined_args); end
189
+ def on_or(node); end
190
+ def process_source(node); end
191
+ def two_start_end_with_calls(param0 = nil); end
192
+ extend RuboCop::Cop::AutoCorrector
193
+ end
194
+ class RuboCop::Cop::Performance::EndWith < RuboCop::Cop::Base
195
+ def on_match_with_lvasgn(node); end
196
+ def on_send(node); end
197
+ def redundant_regex?(param0 = nil); end
198
+ extend RuboCop::Cop::AutoCorrector
199
+ include RuboCop::Cop::RegexpMetacharacter
200
+ end
201
+ class RuboCop::Cop::Performance::FixedSize < RuboCop::Cop::Base
202
+ def allowed_argument?(arg); end
203
+ def allowed_parent?(node); end
204
+ def allowed_variable?(var); end
205
+ def contains_double_splat?(node); end
206
+ def contains_splat?(node); end
207
+ def counter(param0 = nil); end
208
+ def non_string_argument?(node); end
209
+ def on_send(node); end
210
+ end
211
+ class RuboCop::Cop::Performance::FlatMap < RuboCop::Cop::Base
212
+ def autocorrect(corrector, node); end
213
+ def flat_map_candidate?(param0 = nil); end
214
+ def offense_for_levels(node, map_node, first_method, flatten); end
215
+ def offense_for_method(node, map_node, first_method, flatten); end
216
+ def on_send(node); end
217
+ def register_offense(node, map_node, first_method, flatten, message); end
218
+ extend RuboCop::Cop::AutoCorrector
219
+ include RuboCop::Cop::RangeHelp
220
+ end
221
+ class RuboCop::Cop::Performance::InefficientHashSearch < RuboCop::Cop::Base
222
+ def autocorrect_argument(node); end
223
+ def autocorrect_hash_expression(node); end
224
+ def autocorrect_method(node); end
225
+ def current_method(node); end
226
+ def inefficient_include?(param0 = nil); end
227
+ def message(node); end
228
+ def on_send(node); end
229
+ def use_long_method; end
230
+ extend RuboCop::Cop::AutoCorrector
231
+ end
232
+ class RuboCop::Cop::Performance::MethodObjectAsBlock < RuboCop::Cop::Base
233
+ def method_object_as_argument?(param0 = nil); end
234
+ def on_block_pass(node); end
235
+ end
236
+ class RuboCop::Cop::Performance::OpenStruct < RuboCop::Cop::Base
237
+ def on_send(node); end
238
+ def open_struct(param0 = nil); end
239
+ end
240
+ class RuboCop::Cop::Performance::RangeInclude < RuboCop::Cop::Base
241
+ def on_send(node); end
242
+ def range_include(param0 = nil); end
243
+ extend RuboCop::Cop::AutoCorrector
244
+ end
245
+ class RuboCop::Cop::Performance::IoReadlines < RuboCop::Cop::Base
246
+ def autocorrect(corrector, enumerable_call, readlines_call, receiver); end
247
+ def build_bad_method(enumerable_call); end
248
+ def build_call_args(call_args_node); end
249
+ def build_good_method(enumerable_call); end
250
+ def correction_range(enumerable_call, readlines_call); end
251
+ def offense_range(enumerable_call, readlines_call); end
252
+ def on_send(node); end
253
+ def readlines_on_class?(param0 = nil); end
254
+ def readlines_on_instance?(param0 = nil); end
255
+ extend RuboCop::Cop::AutoCorrector
256
+ include RuboCop::Cop::RangeHelp
257
+ end
258
+ class RuboCop::Cop::Performance::RedundantBlockCall < RuboCop::Cop::Base
259
+ def args_include_block_pass?(blockcall); end
260
+ def autocorrect(corrector, node); end
261
+ def blockarg_assigned?(param0, param1); end
262
+ def blockarg_calls(param0, param1); end
263
+ def blockarg_def(param0 = nil); end
264
+ def calls_to_report(argname, body); end
265
+ def on_def(node); end
266
+ extend RuboCop::Cop::AutoCorrector
267
+ end
268
+ class RuboCop::Cop::Performance::RedundantMatch < RuboCop::Cop::Base
269
+ def autocorrect(corrector, node); end
270
+ def match_call?(param0 = nil); end
271
+ def on_send(node); end
272
+ def only_truthiness_matters?(param0 = nil); end
273
+ extend RuboCop::Cop::AutoCorrector
274
+ end
275
+ class RuboCop::Cop::Performance::RedundantMerge < RuboCop::Cop::Base
276
+ def correct_multiple_elements(corrector, node, parent, new_source); end
277
+ def correct_single_element(corrector, node, new_source); end
278
+ def each_redundant_merge(node); end
279
+ def indent_width; end
280
+ def kwsplat_used?(pairs); end
281
+ def leading_spaces(node); end
282
+ def max_key_value_pairs; end
283
+ def message(node); end
284
+ def modifier_flow_control?(param0 = nil); end
285
+ def non_redundant_merge?(node, receiver, pairs); end
286
+ def non_redundant_pairs?(receiver, pairs); end
287
+ def non_redundant_value_used?(receiver, node); end
288
+ def on_send(node); end
289
+ def redundant_merge_candidate(param0 = nil); end
290
+ def rewrite_with_modifier(node, parent, new_source); end
291
+ def to_assignments(receiver, pairs); end
292
+ extend RuboCop::Cop::AutoCorrector
293
+ end
294
+ class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
295
+ def each_with_object_node(param0 = nil); end
296
+ def eligible_receiver?; end
297
+ def initialize(node, receiver); end
298
+ def node; end
299
+ def receiver; end
300
+ def second_argument; end
301
+ def unwind(receiver); end
302
+ def value_used?; end
303
+ extend RuboCop::AST::NodePattern::Macros
304
+ end
305
+ class RuboCop::Cop::Performance::RedundantSortBlock < RuboCop::Cop::Base
306
+ def message(var_a, var_b); end
307
+ def on_block(node); end
308
+ extend RuboCop::Cop::AutoCorrector
309
+ include RuboCop::Cop::SortBlock
310
+ end
311
+ class RuboCop::Cop::Performance::RedundantStringChars < RuboCop::Cop::Base
312
+ def build_bad_method(method, args); end
313
+ def build_call_args(call_args_node); end
314
+ def build_good_method(method, args); end
315
+ def build_message(method, args); end
316
+ def correction_range(receiver, node); end
317
+ def offense_range(receiver, node); end
318
+ def on_send(node); end
319
+ def redundant_chars_call?(param0 = nil); end
320
+ extend RuboCop::Cop::AutoCorrector
321
+ include RuboCop::Cop::RangeHelp
322
+ end
323
+ class RuboCop::Cop::Performance::RegexpMatch < RuboCop::Cop::Base
324
+ def autocorrect(corrector, node); end
325
+ def check_condition(cond); end
326
+ def correct_operator(corrector, recv, arg, oper = nil); end
327
+ def correction_range(recv, arg); end
328
+ def find_last_match(body, range, scope_root); end
329
+ def last_match_used?(match_node); end
330
+ def last_matches(param0); end
331
+ def match_gvar?(sym); end
332
+ def match_method?(param0 = nil); end
333
+ def match_node?(param0 = nil); end
334
+ def match_operator?(param0 = nil); end
335
+ def match_threequals?(param0 = nil); end
336
+ def match_with_int_arg_method?(param0 = nil); end
337
+ def match_with_lvasgn?(node); end
338
+ def message(node); end
339
+ def modifier_form?(match_node); end
340
+ def next_match_pos(body, match_node_pos, scope_root); end
341
+ def on_case(node); end
342
+ def on_if(node); end
343
+ def range_to_search_for_last_matches(match_node, body, scope_root); end
344
+ def replace_with_match_predicate_method(corrector, recv, arg, op_range); end
345
+ def scope_body(node); end
346
+ def scope_root(node); end
347
+ def search_match_nodes(param0); end
348
+ def swap_receiver_and_arg(corrector, recv, arg); end
349
+ extend RuboCop::Cop::AutoCorrector
350
+ end
351
+ class RuboCop::Cop::Performance::ReverseEach < RuboCop::Cop::Base
352
+ def on_send(node); end
353
+ def replacement_range(node); end
354
+ def reverse_each?(param0 = nil); end
355
+ extend RuboCop::Cop::AutoCorrector
356
+ include RuboCop::Cop::RangeHelp
357
+ end
358
+ class RuboCop::Cop::Performance::ReverseFirst < RuboCop::Cop::Base
359
+ def build_bad_method(node); end
360
+ def build_good_method(node); end
361
+ def build_message(node); end
362
+ def correction_range(receiver, node); end
363
+ def on_send(node); end
364
+ def reverse_first_candidate?(param0 = nil); end
365
+ extend RuboCop::Cop::AutoCorrector
366
+ include RuboCop::Cop::RangeHelp
367
+ end
368
+ class RuboCop::Cop::Performance::Size < RuboCop::Cop::Base
369
+ def array?(param0 = nil); end
370
+ def count?(param0 = nil); end
371
+ def hash?(param0 = nil); end
372
+ def on_send(node); end
373
+ extend RuboCop::Cop::AutoCorrector
374
+ end
375
+ class RuboCop::Cop::Performance::SortReverse < RuboCop::Cop::Base
376
+ def message(var_a, var_b); end
377
+ def on_block(node); end
378
+ extend RuboCop::Cop::AutoCorrector
379
+ include RuboCop::Cop::SortBlock
380
+ end
381
+ class RuboCop::Cop::Performance::Squeeze < RuboCop::Cop::Base
382
+ def on_send(node); end
383
+ def repeating_literal?(regex_str); end
384
+ def squeeze_candidate?(param0 = nil); end
385
+ extend RuboCop::Cop::AutoCorrector
386
+ end
387
+ class RuboCop::Cop::Performance::StartWith < RuboCop::Cop::Base
388
+ def on_match_with_lvasgn(node); end
389
+ def on_send(node); end
390
+ def redundant_regex?(param0 = nil); end
391
+ extend RuboCop::Cop::AutoCorrector
392
+ include RuboCop::Cop::RegexpMetacharacter
393
+ end
394
+ class RuboCop::Cop::Performance::StringInclude < RuboCop::Cop::Base
395
+ def literal?(regex_str); end
396
+ def on_match_with_lvasgn(node); end
397
+ def on_send(node); end
398
+ def redundant_regex?(param0 = nil); end
399
+ extend RuboCop::Cop::AutoCorrector
400
+ end
401
+ class RuboCop::Cop::Performance::StringReplacement < RuboCop::Cop::Base
402
+ def accept_first_param?(first_param); end
403
+ def accept_second_param?(second_param); end
404
+ def autocorrect(corrector, node); end
405
+ def first_source(first_param); end
406
+ def message(node, first_source, second_source); end
407
+ def method_suffix(node); end
408
+ def offense(node, first_param, second_param); end
409
+ def on_send(node); end
410
+ def range(node); end
411
+ def remove_second_param(corrector, node, first_param); end
412
+ def replace_method(corrector, node, first_source, second_source, first_param); end
413
+ def replacement_method(node, first_source, second_source); end
414
+ def source_from_regex_constructor(node); end
415
+ def source_from_regex_literal(node); end
416
+ def string_replacement?(param0 = nil); end
417
+ extend RuboCop::Cop::AutoCorrector
418
+ include RuboCop::Cop::RangeHelp
419
+ end
420
+ class RuboCop::Cop::Performance::Sum < RuboCop::Cop::Base
421
+ def acc_plus_elem?(param0 = nil, param1, param2); end
422
+ def array_literal?(node); end
423
+ def autocorrect(corrector, init, range); end
424
+ def autocorrect_sum_map(corrector, sum, map, init); end
425
+ def build_block_bad_method(method, init, var_acc, var_elem, body); end
426
+ def build_block_message(send, init, var_acc, var_elem, body); end
427
+ def build_good_method(init, block_pass = nil); end
428
+ def build_method_bad_method(init, method, operation); end
429
+ def build_method_message(node, method, init, operation); end
430
+ def build_sum_map_message(method, init); end
431
+ def elem_plus_acc?(param0 = nil, param1, param2); end
432
+ def empty_array_literal?(node); end
433
+ def handle_sum_candidate(node); end
434
+ def handle_sum_map_candidate(node); end
435
+ def method_call_with_args_range(node); end
436
+ def on_block(node); end
437
+ def on_send(node); end
438
+ def sum_block_range(send, node); end
439
+ def sum_candidate?(param0 = nil); end
440
+ def sum_map_candidate?(param0 = nil); end
441
+ def sum_map_range(map, sum); end
442
+ def sum_method_range(node); end
443
+ def sum_with_block_candidate?(param0 = nil); end
444
+ extend RuboCop::Cop::AutoCorrector
445
+ include RuboCop::Cop::RangeHelp
446
+ end
447
+ class RuboCop::Cop::Performance::TimesMap < RuboCop::Cop::Base
448
+ def check(node); end
449
+ def message(map_or_collect, count); end
450
+ def on_block(node); end
451
+ def on_send(node); end
452
+ def times_map_call(param0 = nil); end
453
+ extend RuboCop::Cop::AutoCorrector
454
+ end
455
+ class RuboCop::Cop::Performance::UnfreezeString < RuboCop::Cop::Base
456
+ def dup_string?(param0 = nil); end
457
+ def on_send(node); end
458
+ def string_new?(param0 = nil); end
459
+ def string_value(node); end
460
+ extend RuboCop::Cop::AutoCorrector
461
+ end
462
+ class RuboCop::Cop::Performance::UriDefaultParser < RuboCop::Cop::Base
463
+ def on_send(node); end
464
+ def uri_parser_new?(param0 = nil); end
465
+ extend RuboCop::Cop::AutoCorrector
466
+ end
467
+ class RuboCop::Cop::Performance::ChainArrayAllocation < RuboCop::Cop::Base
468
+ def chain_array_allocation?(param0 = nil); end
469
+ def on_send(node); end
470
+ include RuboCop::Cop::RangeHelp
471
+ end