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,280 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
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/rspec-support/all/rspec-support.rbi
9
+ #
10
+ # rspec-support-3.10.1
11
+
12
+ module RSpec
13
+ extend RSpec::Support::Warnings
14
+ end
15
+ module RSpec::Support
16
+ def self.class_of(object); end
17
+ def self.define_optimized_require_for_rspec(lib, &require_relative); end
18
+ def self.deregister_matcher_definition(&block); end
19
+ def self.failure_notifier; end
20
+ def self.failure_notifier=(callable); end
21
+ def self.is_a_matcher?(object); end
22
+ def self.matcher_definitions; end
23
+ def self.method_handle_for(object, method_name); end
24
+ def self.notify_failure(failure, options = nil); end
25
+ def self.register_matcher_definition(&block); end
26
+ def self.require_rspec_support(f); end
27
+ def self.rspec_description_for_object(object); end
28
+ def self.thread_local_data; end
29
+ def self.warning_notifier; end
30
+ def self.warning_notifier=(arg0); end
31
+ def self.with_failure_notifier(callable); end
32
+ end
33
+ module RSpec::Support::Version
34
+ end
35
+ class RSpec::Support::ComparableVersion
36
+ def <=>(other); end
37
+ def initialize(string); end
38
+ def segments; end
39
+ def string; end
40
+ include Comparable
41
+ end
42
+ module RSpec::Support::OS
43
+ def self.windows?; end
44
+ def self.windows_file_path?; end
45
+ def windows?; end
46
+ def windows_file_path?; end
47
+ end
48
+ module RSpec::Support::Ruby
49
+ def jruby?; end
50
+ def jruby_9000?; end
51
+ def jruby_version; end
52
+ def mri?; end
53
+ def non_mri?; end
54
+ def rbx?; end
55
+ def self.jruby?; end
56
+ def self.jruby_9000?; end
57
+ def self.jruby_version; end
58
+ def self.mri?; end
59
+ def self.non_mri?; end
60
+ def self.rbx?; end
61
+ def self.truffleruby?; end
62
+ def truffleruby?; end
63
+ end
64
+ module RSpec::Support::RubyFeatures
65
+ def caller_locations_supported?; end
66
+ def fork_supported?; end
67
+ def kw_args_supported?; end
68
+ def module_prepends_supported?; end
69
+ def module_refinement_supported?; end
70
+ def optional_and_splat_args_supported?; end
71
+ def required_kw_args_supported?; end
72
+ def ripper_supported?; end
73
+ def self.caller_locations_supported?; end
74
+ def self.fork_supported?; end
75
+ def self.kw_args_supported?; end
76
+ def self.module_prepends_supported?; end
77
+ def self.module_refinement_supported?; end
78
+ def self.optional_and_splat_args_supported?; end
79
+ def self.required_kw_args_supported?; end
80
+ def self.ripper_supported?; end
81
+ def self.supports_exception_cause?; end
82
+ def self.supports_rebinding_module_methods?; end
83
+ def self.supports_taint?; end
84
+ def supports_exception_cause?; end
85
+ def supports_rebinding_module_methods?; end
86
+ def supports_taint?; end
87
+ end
88
+ module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
89
+ def self.===(exception); end
90
+ end
91
+ class RSpec::CallerFilter
92
+ def self.first_non_rspec_line(skip_frames = nil, increment = nil); end
93
+ end
94
+ module RSpec::Support::Warnings
95
+ def deprecate(deprecated, options = nil); end
96
+ def warn_deprecation(message, options = nil); end
97
+ def warn_with(message, options = nil); end
98
+ def warning(text, options = nil); end
99
+ end
100
+ class RSpec::Support::EncodedString
101
+ def <<(string); end
102
+ def ==(*args, &block); end
103
+ def detect_source_encoding(string); end
104
+ def empty?(*args, &block); end
105
+ def encoding(*args, &block); end
106
+ def eql?(*args, &block); end
107
+ def initialize(string, encoding = nil); end
108
+ def lines(*args, &block); end
109
+ def matching_encoding(string); end
110
+ def remove_invalid_bytes(string); end
111
+ def self.pick_encoding(source_a, source_b); end
112
+ def source_encoding; end
113
+ def split(regex_or_string); end
114
+ def to_s; end
115
+ def to_str; end
116
+ end
117
+ class RSpec::Support::ReentrantMutex
118
+ def enter; end
119
+ def exit; end
120
+ def initialize; end
121
+ def synchronize; end
122
+ end
123
+ class RSpec::Support::Mutex < Thread::Mutex
124
+ def self.new; end
125
+ end
126
+ class RSpec::Support::DirectoryMaker
127
+ def self.directory_exists?(dirname); end
128
+ def self.generate_path(stack, part); end
129
+ def self.generate_stack(path); end
130
+ def self.mkdir_p(path); end
131
+ end
132
+ class RSpec::Support::MethodSignature
133
+ def arbitrary_kw_args?; end
134
+ def classify_arity(arity = nil); end
135
+ def classify_parameters; end
136
+ def could_contain_kw_args?(args); end
137
+ def description; end
138
+ def has_kw_args_in?(args); end
139
+ def initialize(method); end
140
+ def invalid_kw_args_from(given_kw_args); end
141
+ def max_non_kw_args; end
142
+ def min_non_kw_args; end
143
+ def missing_kw_args_from(given_kw_args); end
144
+ def non_kw_args_arity_description; end
145
+ def optional_kw_args; end
146
+ def required_kw_args; end
147
+ def unlimited_args?; end
148
+ def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end
149
+ end
150
+ class RSpec::Support::MethodSignatureExpectation
151
+ def empty?; end
152
+ def expect_arbitrary_keywords; end
153
+ def expect_arbitrary_keywords=(arg0); end
154
+ def expect_unlimited_arguments; end
155
+ def expect_unlimited_arguments=(arg0); end
156
+ def initialize; end
157
+ def keywords; end
158
+ def keywords=(values); end
159
+ def max_count; end
160
+ def max_count=(number); end
161
+ def min_count; end
162
+ def min_count=(number); end
163
+ end
164
+ class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature
165
+ def classify_parameters; end
166
+ end
167
+ class RSpec::Support::MethodSignatureVerifier
168
+ def arbitrary_kw_args?; end
169
+ def error_message; end
170
+ def initialize(signature, args = nil); end
171
+ def invalid_kw_args; end
172
+ def kw_args; end
173
+ def max_non_kw_args; end
174
+ def min_non_kw_args; end
175
+ def missing_kw_args; end
176
+ def non_kw_args; end
177
+ def split_args(*args); end
178
+ def unlimited_args?; end
179
+ def valid?; end
180
+ def valid_non_kw_args?; end
181
+ def with_expectation(expectation); end
182
+ end
183
+ class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier
184
+ def split_args(*args); end
185
+ end
186
+ class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
187
+ def has_kw_args_in?(args); end
188
+ def initialize(signature); end
189
+ def invalid_kw_args_from(_kw_args); end
190
+ def missing_kw_args_from(_kw_args); end
191
+ def non_kw_args_arity_description; end
192
+ def valid_non_kw_args?(*args); end
193
+ end
194
+ module RSpec::Support::WithKeywordsWhenNeeded
195
+ def class_exec(klass, *args, &block); end
196
+ def self.class_exec(klass, *args, &block); end
197
+ end
198
+ module RSpec::Support::RecursiveConstMethods
199
+ def const_defined_on?(mod, const_name); end
200
+ def constants_defined_on(mod); end
201
+ def get_const_defined_on(mod, const_name); end
202
+ def normalize_const_name(const_name); end
203
+ def recursive_const_defined?(const_name); end
204
+ def recursive_const_get(const_name); end
205
+ end
206
+ class RSpec::Support::ObjectFormatter
207
+ def format(object); end
208
+ def initialize(max_formatted_output_length = nil); end
209
+ def max_formatted_output_length; end
210
+ def max_formatted_output_length=(arg0); end
211
+ def prepare_array(array); end
212
+ def prepare_element(element); end
213
+ def prepare_for_inspection(object); end
214
+ def prepare_hash(input_hash); end
215
+ def recursive_structure?(object); end
216
+ def self.default_instance; end
217
+ def self.format(object); end
218
+ def self.prepare_for_inspection(object); end
219
+ def sort_hash_keys(input_hash); end
220
+ def truncate_string(str, start_index, end_index); end
221
+ def with_entering_structure(structure); end
222
+ end
223
+ class RSpec::Support::ObjectFormatter::InspectableItem < Struct
224
+ def inspect; end
225
+ def pretty_print(pp); end
226
+ def self.[](*arg0); end
227
+ def self.inspect; end
228
+ def self.members; end
229
+ def self.new(*arg0); end
230
+ def text; end
231
+ def text=(_); end
232
+ end
233
+ class RSpec::Support::ObjectFormatter::BaseInspector < Struct
234
+ def formatter; end
235
+ def formatter=(_); end
236
+ def inspect; end
237
+ def object; end
238
+ def object=(_); end
239
+ def pretty_print(pp); end
240
+ def self.[](*arg0); end
241
+ def self.can_inspect?(_object); end
242
+ def self.inspect; end
243
+ def self.members; end
244
+ def self.new(*arg0); end
245
+ end
246
+ class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
247
+ def inspect; end
248
+ def self.can_inspect?(object); end
249
+ end
250
+ class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
251
+ def inspect; end
252
+ def self.can_inspect?(object); end
253
+ end
254
+ class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector
255
+ def inspect; end
256
+ def self.can_inspect?(object); end
257
+ end
258
+ class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector
259
+ def inspect; end
260
+ def self.can_inspect?(object); end
261
+ end
262
+ class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
263
+ def inspect; end
264
+ def klass; end
265
+ def native_object_id; end
266
+ def self.can_inspect?(object); end
267
+ end
268
+ class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector
269
+ def inspect; end
270
+ def self.can_inspect?(object); end
271
+ end
272
+ class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
273
+ def inspect; end
274
+ def self.can_inspect?(object); end
275
+ end
276
+ module RSpec::Support::FuzzyMatcher
277
+ def self.arrays_match?(expected_list, actual_list); end
278
+ def self.hashes_match?(expected_hash, actual_hash); end
279
+ def self.values_match?(expected, actual); end
280
+ end
@@ -0,0 +1,15 @@
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/rspec/all/rspec.rbi
9
+ #
10
+ # rspec-3.10.0
11
+
12
+ module RSpec
13
+ end
14
+ module RSpec::Version
15
+ end
@@ -0,0 +1,1351 @@
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-ast/all/rubocop-ast.rbi
9
+ #
10
+ # rubocop-ast-1.3.0
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::AST
15
+ extend RuboCop::AST::RuboCopCompatibility
16
+ end
17
+ module RuboCop::AST::Ext
18
+ end
19
+ module RuboCop::AST::Ext::Range
20
+ def line_span(exclude_end: nil); end
21
+ end
22
+ class Parser::Source::Range
23
+ include RuboCop::AST::Ext::Range
24
+ end
25
+ module RuboCop::AST::Ext::RangeMinMax
26
+ end
27
+ class RuboCop::AST::NodePattern
28
+ def ==(other); end
29
+ def as_json(_options = nil); end
30
+ def ast; end
31
+ def captures(*args, &block); end
32
+ def encode_with(coder); end
33
+ def eql?(other); end
34
+ def freeze; end
35
+ def init_with(coder); end
36
+ def initialize(str, compiler: nil); end
37
+ def marshal_dump; end
38
+ def marshal_load(pattern); end
39
+ def match(*args, **rest, &block); end
40
+ def match_code; end
41
+ def named_parameters(*args, &block); end
42
+ def pattern; end
43
+ def positional_parameters(*args, &block); end
44
+ def self.descend(element, &block); end
45
+ def to_s; end
46
+ extend Forwardable
47
+ include RuboCop::AST::NodePattern::MethodDefiner
48
+ end
49
+ module RuboCop::AST::NodePattern::MethodDefiner
50
+ def as_lambda; end
51
+ def compile_as_lambda; end
52
+ def compile_init; end
53
+ def def_helper(base, method_name, **defaults); end
54
+ def def_node_matcher(base, method_name, **defaults); end
55
+ def def_node_search(base, method_name, **defaults); end
56
+ def emit_keyword_list(forwarding: nil); end
57
+ def emit_lambda_code; end
58
+ def emit_method_code; end
59
+ def emit_node_search(method_name); end
60
+ def emit_node_search_body(method_name, prelude:, on_match:); end
61
+ def emit_param_list; end
62
+ def emit_params(*first, forwarding: nil); end
63
+ def emit_retval; end
64
+ def emit_yield_capture(when_no_capture = nil, yield_with: nil); end
65
+ def wrapping_block(method_name, **defaults); end
66
+ end
67
+ module RuboCop::AST::NodePattern::Macros
68
+ def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
69
+ def def_node_search(method_name, pattern_str, **keyword_defaults); end
70
+ end
71
+ class RuboCop::AST::NodePattern::Invalid < StandardError
72
+ end
73
+ module RuboCop::AST::Descendence
74
+ def child_nodes; end
75
+ def descendants; end
76
+ def each_child_node(*types); end
77
+ def each_descendant(*types, &block); end
78
+ def each_node(*types, &block); end
79
+ def visit_descendants(types, &block); end
80
+ end
81
+ class RuboCop::AST::NodePattern::Builder
82
+ def emit_atom(type, value); end
83
+ def emit_call(type, selector, args = nil); end
84
+ def emit_capture(capture_token, node); end
85
+ def emit_list(type, _begin, children, _end); end
86
+ def emit_subsequence(node_list); end
87
+ def emit_unary_op(type, _operator = nil, *children); end
88
+ def emit_union(begin_t, pattern_lists, end_t); end
89
+ def n(type, *args); end
90
+ def optimizable_as_set?(children); end
91
+ def union_children(pattern_lists); end
92
+ end
93
+ class RuboCop::AST::NodePattern::Comment
94
+ def ==(other); end
95
+ def initialize(range); end
96
+ def inspect; end
97
+ def loc; end
98
+ def location; end
99
+ def text; end
100
+ end
101
+ class RuboCop::AST::NodePattern::Compiler
102
+ def bind(*args, &block); end
103
+ def binding; end
104
+ def captures; end
105
+ def compile_as_atom(node); end
106
+ def compile_as_node_pattern(node, **options); end
107
+ def compile_sequence(sequence, var:); end
108
+ def each_union(enum, &block); end
109
+ def enforce_same_captures(enum); end
110
+ def freeze; end
111
+ def initialize; end
112
+ def named_parameter(name); end
113
+ def named_parameters; end
114
+ def new_capture; end
115
+ def next_capture; end
116
+ def parser; end
117
+ def positional_parameter(number); end
118
+ def positional_parameters; end
119
+ def with_temp_variables(*names, &block); end
120
+ extend Forwardable
121
+ end
122
+ class RuboCop::AST::NodePattern::Compiler::Subcompiler
123
+ def compile(node); end
124
+ def compiler; end
125
+ def do_compile; end
126
+ def initialize(compiler); end
127
+ def node; end
128
+ def self.inherited(base); end
129
+ def self.method_added(method); end
130
+ def self.registry; end
131
+ end
132
+ class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
133
+ def visit_const; end
134
+ def visit_named_parameter; end
135
+ def visit_number; end
136
+ def visit_other_type; end
137
+ def visit_positional_parameter; end
138
+ def visit_regexp; end
139
+ def visit_set; end
140
+ def visit_string; end
141
+ def visit_symbol; end
142
+ def visit_unify; end
143
+ end
144
+ class RuboCop::AST::NodePattern::Compiler::Binding
145
+ def bind(name); end
146
+ def forbid(names); end
147
+ def initialize; end
148
+ def union_bind(enum); end
149
+ end
150
+ class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
151
+ def access; end
152
+ def access_element; end
153
+ def access_node; end
154
+ def compile_args(arg_list, first: nil); end
155
+ def compile_guard_clause; end
156
+ def compile_value_match(value); end
157
+ def initialize(compiler, var: nil, access: nil, seq_head: nil); end
158
+ def multiple_access(kind); end
159
+ def seq_head; end
160
+ def visit_ascend; end
161
+ def visit_capture; end
162
+ def visit_descend; end
163
+ def visit_function_call; end
164
+ def visit_intersection; end
165
+ def visit_negation; end
166
+ def visit_node_type; end
167
+ def visit_other_type; end
168
+ def visit_predicate; end
169
+ def visit_sequence; end
170
+ def visit_unify; end
171
+ def visit_union; end
172
+ def visit_wildcard; end
173
+ end
174
+ class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler
175
+ def compile(node); end
176
+ def compile_and_advance(term); end
177
+ def compile_any_order_branches(matched_var); end
178
+ def compile_any_order_else; end
179
+ def compile_captured_repetition(child_code, child_captures); end
180
+ def compile_case(when_branches, else_code); end
181
+ def compile_child_nb_guard(arity_range); end
182
+ def compile_cur_index; end
183
+ def compile_index(cur = nil); end
184
+ def compile_loop(term); end
185
+ def compile_loop_advance(to = nil); end
186
+ def compile_matched(kind); end
187
+ def compile_max_matched; end
188
+ def compile_min_check; end
189
+ def compile_remaining; end
190
+ def compile_sequence; end
191
+ def compile_terms(children = nil, last_arity = nil); end
192
+ def compile_union_forks; end
193
+ def cur_index; end
194
+ def empty_loop; end
195
+ def handle_prev; end
196
+ def in_sync; end
197
+ def initialize(compiler, sequence:, var:); end
198
+ def merge_forks!(forks); end
199
+ def preserve_union_start(forks); end
200
+ def remaining_arities(children, last_arity); end
201
+ def sync; end
202
+ def use_index_from_end; end
203
+ def visit_any_order; end
204
+ def visit_capture; end
205
+ def visit_other_type; end
206
+ def visit_repetition; end
207
+ def visit_rest; end
208
+ def visit_union; end
209
+ def within_loop; end
210
+ end
211
+ class RuboCop::AST::NodePattern::LexerRex
212
+ def action; end
213
+ def filename; end
214
+ def filename=(arg0); end
215
+ def location; end
216
+ def match; end
217
+ def matches; end
218
+ def next_token; end
219
+ def parse(str); end
220
+ def parse_file(path); end
221
+ def scanner_class; end
222
+ def ss; end
223
+ def ss=(arg0); end
224
+ def state; end
225
+ def state=(arg0); end
226
+ end
227
+ class RuboCop::AST::NodePattern::LexerRex::LexerError < StandardError
228
+ end
229
+ class RuboCop::AST::NodePattern::LexerRex::ScanError < RuboCop::AST::NodePattern::LexerRex::LexerError
230
+ end
231
+ class RuboCop::AST::NodePattern::Lexer < RuboCop::AST::NodePattern::LexerRex
232
+ def comments; end
233
+ def do_parse; end
234
+ def emit(type); end
235
+ def emit_comment; end
236
+ def emit_regexp; end
237
+ def initialize(source); end
238
+ def source_buffer; end
239
+ def token(type, value); end
240
+ def tokens; end
241
+ end
242
+ class RuboCop::AST::NodePattern::Node < Parser::AST::Node
243
+ def arity; end
244
+ def arity_range; end
245
+ def capture?; end
246
+ def child; end
247
+ def children_nodes; end
248
+ def in_sequence_head; end
249
+ def matches_within_set?; end
250
+ def nb_captures; end
251
+ def rest?; end
252
+ def variadic?; end
253
+ def with(type: nil, children: nil, location: nil); end
254
+ extend Forwardable
255
+ include RuboCop::AST::Descendence
256
+ end
257
+ module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
258
+ def in_sequence_head; end
259
+ end
260
+ class RuboCop::AST::NodePattern::Node::Capture < RuboCop::AST::NodePattern::Node
261
+ def arity(*args, &block); end
262
+ def capture?; end
263
+ def in_sequence_head; end
264
+ def nb_captures; end
265
+ def rest?(*args, &block); end
266
+ end
267
+ class RuboCop::AST::NodePattern::Node::Sequence < RuboCop::AST::NodePattern::Node
268
+ def initialize(type, children = nil, properties = nil); end
269
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
270
+ end
271
+ class RuboCop::AST::NodePattern::Node::Predicate < RuboCop::AST::NodePattern::Node
272
+ def arg_list; end
273
+ def method_name; end
274
+ end
275
+ class RuboCop::AST::NodePattern::Node::Repetition < RuboCop::AST::NodePattern::Node
276
+ def arity; end
277
+ def operator; end
278
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
279
+ end
280
+ class RuboCop::AST::NodePattern::Node::Rest < RuboCop::AST::NodePattern::Node
281
+ def arity; end
282
+ def in_sequence_head; end
283
+ def rest?; end
284
+ end
285
+ class RuboCop::AST::NodePattern::Node::AnyOrder < RuboCop::AST::NodePattern::Node
286
+ def arity; end
287
+ def ends_with_rest?; end
288
+ def rest_node; end
289
+ def term_nodes; end
290
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
291
+ end
292
+ class RuboCop::AST::NodePattern::Node::Subsequence < RuboCop::AST::NodePattern::Node
293
+ def arity; end
294
+ def in_sequence_head; end
295
+ include RuboCop::AST::NodePattern::Node::ForbidInSeqHead
296
+ end
297
+ class RuboCop::AST::NodePattern::Node::Union < RuboCop::AST::NodePattern::Node
298
+ def arity; end
299
+ def in_sequence_head; end
300
+ end
301
+ class RuboCop::AST::NodePattern::Parser < Racc::Parser
302
+ def _reduce_10(val, _values); end
303
+ def _reduce_11(val, _values); end
304
+ def _reduce_13(val, _values); end
305
+ def _reduce_14(val, _values); end
306
+ def _reduce_15(val, _values); end
307
+ def _reduce_16(val, _values); end
308
+ def _reduce_17(val, _values); end
309
+ def _reduce_18(val, _values); end
310
+ def _reduce_19(val, _values); end
311
+ def _reduce_2(val, _values); end
312
+ def _reduce_20(val, _values); end
313
+ def _reduce_21(val, _values); end
314
+ def _reduce_22(val, _values); end
315
+ def _reduce_25(val, _values); end
316
+ def _reduce_26(val, _values); end
317
+ def _reduce_3(val, _values); end
318
+ def _reduce_33(val, _values); end
319
+ def _reduce_37(val, _values); end
320
+ def _reduce_38(val, _values); end
321
+ def _reduce_39(val, _values); end
322
+ def _reduce_4(val, _values); end
323
+ def _reduce_40(val, _values); end
324
+ def _reduce_41(val, _values); end
325
+ def _reduce_42(val, _values); end
326
+ def _reduce_43(val, _values); end
327
+ def _reduce_44(val, _values); end
328
+ def _reduce_45(val, _values); end
329
+ def _reduce_46(val, _values); end
330
+ def _reduce_5(val, _values); end
331
+ def _reduce_6(val, _values); end
332
+ def _reduce_7(val, _values); end
333
+ def _reduce_8(val, _values); end
334
+ def _reduce_9(val, _values); end
335
+ def _reduce_none(val, _values); end
336
+ def emit_atom(*args, &block); end
337
+ def emit_call(*args, &block); end
338
+ def emit_capture(*args, &block); end
339
+ def emit_list(*args, &block); end
340
+ def emit_unary_op(*args, &block); end
341
+ def emit_union(*args, &block); end
342
+ def enforce_unary(node); end
343
+ def initialize(builder = nil); end
344
+ def inspect; end
345
+ def next_token(*args, &block); end
346
+ def on_error(token, val, _vstack); end
347
+ def parse(source); end
348
+ extend Forwardable
349
+ end
350
+ module RuboCop::AST::NodePattern::Sets
351
+ def self.[](set); end
352
+ def self.name(set); end
353
+ def self.uniq(name); end
354
+ end
355
+ module RuboCop::AST::Sexp
356
+ def s(type, *children); end
357
+ end
358
+ class RuboCop::AST::Node < Parser::AST::Node
359
+ def __ENCODING___type?; end
360
+ def __FILE___type?; end
361
+ def __LINE___type?; end
362
+ def alias_type?; end
363
+ def ancestors; end
364
+ def and_asgn_type?; end
365
+ def and_type?; end
366
+ def arg_expr_type?; end
367
+ def arg_type?; end
368
+ def args_type?; end
369
+ def argument?; end
370
+ def argument_type?; end
371
+ def array_pattern_type?; end
372
+ def array_pattern_with_tail_type?; end
373
+ def array_type?; end
374
+ def assignment?; end
375
+ def assignment_or_similar?(param0 = nil); end
376
+ def back_ref_type?; end
377
+ def basic_conditional?; end
378
+ def basic_literal?; end
379
+ def begin_type?; end
380
+ def begin_value_used?; end
381
+ def block_pass_type?; end
382
+ def block_type?; end
383
+ def blockarg_expr_type?; end
384
+ def blockarg_type?; end
385
+ def boolean_type?; end
386
+ def break_type?; end
387
+ def call_type?; end
388
+ def case_if_value_used?; end
389
+ def case_match_type?; end
390
+ def case_type?; end
391
+ def casgn_type?; end
392
+ def cbase_type?; end
393
+ def chained?; end
394
+ def class_constructor?(param0 = nil); end
395
+ def class_definition?(param0 = nil); end
396
+ def class_type?; end
397
+ def complete!; end
398
+ def complete?; end
399
+ def complex_type?; end
400
+ def conditional?; end
401
+ def const_name; end
402
+ def const_pattern_type?; end
403
+ def const_type?; end
404
+ def csend_type?; end
405
+ def cvar_type?; end
406
+ def cvasgn_type?; end
407
+ def def_type?; end
408
+ def defined_module0(param0 = nil); end
409
+ def defined_module; end
410
+ def defined_module_name; end
411
+ def defined_type?; end
412
+ def defs_type?; end
413
+ def dstr_type?; end
414
+ def dsym_type?; end
415
+ def each_ancestor(*types, &block); end
416
+ def eflipflop_type?; end
417
+ def empty_else_type?; end
418
+ def empty_source?; end
419
+ def ensure_type?; end
420
+ def equals_asgn?; end
421
+ def erange_type?; end
422
+ def false_type?; end
423
+ def falsey_literal?; end
424
+ def find_pattern_type?; end
425
+ def first_line; end
426
+ def float_type?; end
427
+ def for_type?; end
428
+ def for_value_used?; end
429
+ def forward_arg_type?; end
430
+ def forward_args_type?; end
431
+ def forwarded_args_type?; end
432
+ def global_const?(param0 = nil, param1); end
433
+ def guard_clause?; end
434
+ def gvar_type?; end
435
+ def gvasgn_type?; end
436
+ def hash_pattern_type?; end
437
+ def hash_type?; end
438
+ def ident_type?; end
439
+ def if_guard_type?; end
440
+ def if_type?; end
441
+ def iflipflop_type?; end
442
+ def immutable_literal?; end
443
+ def in_match_type?; end
444
+ def in_pattern_type?; end
445
+ def index_type?; end
446
+ def indexasgn_type?; end
447
+ def initialize(type, children = nil, properties = nil); end
448
+ def int_type?; end
449
+ def irange_type?; end
450
+ def ivar_type?; end
451
+ def ivasgn_type?; end
452
+ def keyword?; end
453
+ def kwarg_type?; end
454
+ def kwargs_type?; end
455
+ def kwbegin_type?; end
456
+ def kwnilarg_type?; end
457
+ def kwoptarg_type?; end
458
+ def kwrestarg_type?; end
459
+ def kwsplat_type?; end
460
+ def lambda?(param0 = nil); end
461
+ def lambda_or_proc?(param0 = nil); end
462
+ def lambda_type?; end
463
+ def last_line; end
464
+ def left_sibling; end
465
+ def left_siblings; end
466
+ def line_count; end
467
+ def literal?; end
468
+ def loop_keyword?; end
469
+ def lvar_type?; end
470
+ def lvasgn_type?; end
471
+ def masgn_type?; end
472
+ def match_alt_type?; end
473
+ def match_as_type?; end
474
+ def match_current_line_type?; end
475
+ def match_guard_clause?(param0 = nil); end
476
+ def match_nil_pattern_type?; end
477
+ def match_pattern_p_type?; end
478
+ def match_pattern_type?; end
479
+ def match_rest_type?; end
480
+ def match_var_type?; end
481
+ def match_with_lvasgn_type?; end
482
+ def match_with_trailing_comma_type?; end
483
+ def mlhs_type?; end
484
+ def module_definition?(param0 = nil); end
485
+ def module_type?; end
486
+ def multiline?; end
487
+ def mutable_literal?; end
488
+ def new_class_or_module_block?(param0 = nil); end
489
+ def next_type?; end
490
+ def nil_type?; end
491
+ def node_parts; end
492
+ def nonempty_line_count; end
493
+ def not_type?; end
494
+ def nth_ref_type?; end
495
+ def numargs_type?; end
496
+ def numblock_type?; end
497
+ def numeric_type?; end
498
+ def objc_kwarg_type?; end
499
+ def objc_restarg_type?; end
500
+ def objc_varargs_type?; end
501
+ def op_asgn_type?; end
502
+ def operator_keyword?; end
503
+ def optarg_type?; end
504
+ def or_asgn_type?; end
505
+ def or_type?; end
506
+ def pair_type?; end
507
+ def parent; end
508
+ def parent=(node); end
509
+ def parent?; end
510
+ def parent_module_name; end
511
+ def parent_module_name_for_block(ancestor); end
512
+ def parent_module_name_for_sclass(sclass_node); end
513
+ def parent_module_name_part(node); end
514
+ def parenthesized_call?; end
515
+ def pin_type?; end
516
+ def post_condition_loop?; end
517
+ def postexe_type?; end
518
+ def preexe_type?; end
519
+ def proc?(param0 = nil); end
520
+ def procarg0_type?; end
521
+ def pure?; end
522
+ def range_type?; end
523
+ def rational_type?; end
524
+ def receiver(param0 = nil); end
525
+ def recursive_basic_literal?; end
526
+ def recursive_literal?; end
527
+ def redo_type?; end
528
+ def reference?; end
529
+ def regexp_type?; end
530
+ def regopt_type?; end
531
+ def resbody_type?; end
532
+ def rescue_type?; end
533
+ def restarg_expr_type?; end
534
+ def restarg_type?; end
535
+ def retry_type?; end
536
+ def return_type?; end
537
+ def right_sibling; end
538
+ def right_siblings; end
539
+ def root?; end
540
+ def sclass_type?; end
541
+ def self_type?; end
542
+ def send_type?; end
543
+ def shadowarg_type?; end
544
+ def shorthand_asgn?; end
545
+ def sibling_index; end
546
+ def single_line?; end
547
+ def source; end
548
+ def source_length; end
549
+ def source_range; end
550
+ def special_keyword?; end
551
+ def splat_type?; end
552
+ def str_content(param0 = nil); end
553
+ def str_type?; end
554
+ def struct_constructor?(param0 = nil); end
555
+ def super_type?; end
556
+ def sym_type?; end
557
+ def true_type?; end
558
+ def truthy_literal?; end
559
+ def undef_type?; end
560
+ def unless_guard_type?; end
561
+ def until_post_type?; end
562
+ def until_type?; end
563
+ def updated(type = nil, children = nil, properties = nil); end
564
+ def value_used?; end
565
+ def variable?; end
566
+ def visit_ancestors(types); end
567
+ def when_type?; end
568
+ def while_post_type?; end
569
+ def while_type?; end
570
+ def while_until_value_used?; end
571
+ def xstr_type?; end
572
+ def yield_type?; end
573
+ def zsuper_type?; end
574
+ extend RuboCop::AST::NodePattern::Macros
575
+ include RuboCop::AST::Descendence
576
+ include RuboCop::AST::Sexp
577
+ end
578
+ module RuboCop::AST::MethodIdentifierPredicates
579
+ def assignment_method?; end
580
+ def bang_method?; end
581
+ def camel_case_method?; end
582
+ def comparison_method?; end
583
+ def const_receiver?; end
584
+ def enumerable_method?; end
585
+ def enumerator_method?; end
586
+ def method?(name); end
587
+ def negation_method?; end
588
+ def nonmutating_array_method?; end
589
+ def nonmutating_binary_operator_method?; end
590
+ def nonmutating_hash_method?; end
591
+ def nonmutating_operator_method?; end
592
+ def nonmutating_string_method?; end
593
+ def nonmutating_unary_operator_method?; end
594
+ def operator_method?; end
595
+ def predicate_method?; end
596
+ def prefix_bang?; end
597
+ def prefix_not?; end
598
+ def self_receiver?; end
599
+ end
600
+ module RuboCop::AST::BinaryOperatorNode
601
+ def conditions; end
602
+ def lhs; end
603
+ def rhs; end
604
+ end
605
+ module RuboCop::AST::CollectionNode
606
+ def &(*args, &block); end
607
+ def *(*args, &block); end
608
+ def +(*args, &block); end
609
+ def -(*args, &block); end
610
+ def <<(*args, &block); end
611
+ def [](*args, &block); end
612
+ def []=(*args, &block); end
613
+ def all?(*args, &block); end
614
+ def any?(*args, &block); end
615
+ def append(*args, &block); end
616
+ def assoc(*args, &block); end
617
+ def at(*args, &block); end
618
+ def bsearch(*args, &block); end
619
+ def bsearch_index(*args, &block); end
620
+ def chain(*args, &block); end
621
+ def chunk(*args, &block); end
622
+ def chunk_while(*args, &block); end
623
+ def clear(*args, &block); end
624
+ def collect!(*args, &block); end
625
+ def collect(*args, &block); end
626
+ def collect_concat(*args, &block); end
627
+ def combination(*args, &block); end
628
+ def compact!(*args, &block); end
629
+ def compact(*args, &block); end
630
+ def concat(*args, &block); end
631
+ def count(*args, &block); end
632
+ def cycle(*args, &block); end
633
+ def deconstruct(*args, &block); end
634
+ def delete(*args, &block); end
635
+ def delete_at(*args, &block); end
636
+ def delete_if(*args, &block); end
637
+ def detect(*args, &block); end
638
+ def difference(*args, &block); end
639
+ def dig(*args, &block); end
640
+ def drop(*args, &block); end
641
+ def drop_while(*args, &block); end
642
+ def each(*args, &block); end
643
+ def each_cons(*args, &block); end
644
+ def each_entry(*args, &block); end
645
+ def each_index(*args, &block); end
646
+ def each_slice(*args, &block); end
647
+ def each_with_index(*args, &block); end
648
+ def each_with_object(*args, &block); end
649
+ def empty?(*args, &block); end
650
+ def entries(*args, &block); end
651
+ def fetch(*args, &block); end
652
+ def fill(*args, &block); end
653
+ def filter!(*args, &block); end
654
+ def filter(*args, &block); end
655
+ def filter_map(*args, &block); end
656
+ def find(*args, &block); end
657
+ def find_all(*args, &block); end
658
+ def find_index(*args, &block); end
659
+ def first(*args, &block); end
660
+ def flat_map(*args, &block); end
661
+ def flatten!(*args, &block); end
662
+ def flatten(*args, &block); end
663
+ def grep(*args, &block); end
664
+ def grep_v(*args, &block); end
665
+ def group_by(*args, &block); end
666
+ def include?(*args, &block); end
667
+ def index(*args, &block); end
668
+ def inject(*args, &block); end
669
+ def insert(*args, &block); end
670
+ def intersection(*args, &block); end
671
+ def join(*args, &block); end
672
+ def keep_if(*args, &block); end
673
+ def last(*args, &block); end
674
+ def lazy(*args, &block); end
675
+ def length(*args, &block); end
676
+ def map!(*args, &block); end
677
+ def map(*args, &block); end
678
+ def max(*args, &block); end
679
+ def max_by(*args, &block); end
680
+ def member?(*args, &block); end
681
+ def min(*args, &block); end
682
+ def min_by(*args, &block); end
683
+ def minmax(*args, &block); end
684
+ def minmax_by(*args, &block); end
685
+ def none?(*args, &block); end
686
+ def one?(*args, &block); end
687
+ def pack(*args, &block); end
688
+ def partition(*args, &block); end
689
+ def permutation(*args, &block); end
690
+ def pop(*args, &block); end
691
+ def prepend(*args, &block); end
692
+ def product(*args, &block); end
693
+ def push(*args, &block); end
694
+ def rassoc(*args, &block); end
695
+ def reduce(*args, &block); end
696
+ def reject!(*args, &block); end
697
+ def reject(*args, &block); end
698
+ def repeated_combination(*args, &block); end
699
+ def repeated_permutation(*args, &block); end
700
+ def replace(*args, &block); end
701
+ def reverse!(*args, &block); end
702
+ def reverse(*args, &block); end
703
+ def reverse_each(*args, &block); end
704
+ def rindex(*args, &block); end
705
+ def rotate!(*args, &block); end
706
+ def rotate(*args, &block); end
707
+ def sample(*args, &block); end
708
+ def select!(*args, &block); end
709
+ def select(*args, &block); end
710
+ def shelljoin(*args, &block); end
711
+ def shift(*args, &block); end
712
+ def shuffle!(*args, &block); end
713
+ def shuffle(*args, &block); end
714
+ def size(*args, &block); end
715
+ def slice!(*args, &block); end
716
+ def slice(*args, &block); end
717
+ def slice_after(*args, &block); end
718
+ def slice_before(*args, &block); end
719
+ def slice_when(*args, &block); end
720
+ def sort!(*args, &block); end
721
+ def sort(*args, &block); end
722
+ def sort_by!(*args, &block); end
723
+ def sort_by(*args, &block); end
724
+ def sum(*args, &block); end
725
+ def take(*args, &block); end
726
+ def take_while(*args, &block); end
727
+ def tally(*args, &block); end
728
+ def to_ary(*args, &block); end
729
+ def to_h(*args, &block); end
730
+ def to_set(*args, &block); end
731
+ def transpose(*args, &block); end
732
+ def union(*args, &block); end
733
+ def uniq!(*args, &block); end
734
+ def uniq(*args, &block); end
735
+ def unshift(*args, &block); end
736
+ def values_at(*args, &block); end
737
+ def zip(*args, &block); end
738
+ def |(*args, &block); end
739
+ extend Forwardable
740
+ end
741
+ module RuboCop::AST::ConditionalNode
742
+ def body; end
743
+ def condition; end
744
+ def multiline_condition?; end
745
+ def single_line_condition?; end
746
+ end
747
+ module RuboCop::AST::HashElementNode
748
+ def delimiter_delta(other); end
749
+ def key; end
750
+ def key_delta(other, alignment = nil); end
751
+ def same_line?(other); end
752
+ def value; end
753
+ def value_delta(other); end
754
+ end
755
+ class RuboCop::AST::HashElementNode::HashElementDelta
756
+ def delimiter_delta; end
757
+ def delta(first, second, alignment = nil); end
758
+ def first; end
759
+ def initialize(first, second); end
760
+ def key_delta(alignment = nil); end
761
+ def keyword_splat?; end
762
+ def second; end
763
+ def valid_argument_types?; end
764
+ def value_delta; end
765
+ end
766
+ module RuboCop::AST::MethodDispatchNode
767
+ def access_modifier?; end
768
+ def adjacent_def_modifier?(param0 = nil); end
769
+ def arithmetic_operation?; end
770
+ def assignment?; end
771
+ def bare_access_modifier?; end
772
+ def bare_access_modifier_declaration?(param0 = nil); end
773
+ def binary_operation?; end
774
+ def block_literal?; end
775
+ def block_node; end
776
+ def command?(name); end
777
+ def const_receiver?; end
778
+ def def_modifier?; end
779
+ def dot?; end
780
+ def double_colon?; end
781
+ def implicit_call?; end
782
+ def in_macro_scope?(param0 = nil); end
783
+ def lambda?; end
784
+ def lambda_literal?; end
785
+ def macro?; end
786
+ def method_name; end
787
+ def non_bare_access_modifier?; end
788
+ def non_bare_access_modifier_declaration?(param0 = nil); end
789
+ def receiver; end
790
+ def safe_navigation?; end
791
+ def self_receiver?; end
792
+ def setter_method?; end
793
+ def special_modifier?; end
794
+ def unary_operation?; end
795
+ extend RuboCop::AST::NodePattern::Macros
796
+ include RuboCop::AST::MethodIdentifierPredicates
797
+ end
798
+ module RuboCop::AST::ModifierNode
799
+ def modifier_form?; end
800
+ end
801
+ module RuboCop::AST::NumericNode
802
+ def sign?; end
803
+ end
804
+ module RuboCop::AST::ParameterizedNode
805
+ def arguments?; end
806
+ def block_argument?; end
807
+ def first_argument; end
808
+ def last_argument; end
809
+ def parenthesized?; end
810
+ def rest_argument?; end
811
+ def splat_argument?; end
812
+ end
813
+ module RuboCop::AST::ParameterizedNode::WrappedArguments
814
+ def arguments; end
815
+ include RuboCop::AST::ParameterizedNode
816
+ end
817
+ module RuboCop::AST::ParameterizedNode::RestArguments
818
+ def arguments; end
819
+ def arguments?; end
820
+ def first_argument; end
821
+ def last_argument; end
822
+ include RuboCop::AST::ParameterizedNode
823
+ end
824
+ module RuboCop::AST::PredicateOperatorNode
825
+ def logical_operator?; end
826
+ def operator; end
827
+ def semantic_operator?; end
828
+ end
829
+ module RuboCop::AST::BasicLiteralNode
830
+ def value; end
831
+ end
832
+ class RuboCop::AST::AliasNode < RuboCop::AST::Node
833
+ def new_identifier; end
834
+ def old_identifier; end
835
+ end
836
+ class RuboCop::AST::AndNode < RuboCop::AST::Node
837
+ def alternate_operator; end
838
+ def inverse_operator; end
839
+ include RuboCop::AST::BinaryOperatorNode
840
+ include RuboCop::AST::PredicateOperatorNode
841
+ end
842
+ class RuboCop::AST::ArgNode < RuboCop::AST::Node
843
+ def default?; end
844
+ def default_value; end
845
+ def name; end
846
+ end
847
+ class RuboCop::AST::ArgsNode < RuboCop::AST::Node
848
+ def argument_list; end
849
+ def empty_and_without_delimiters?; end
850
+ include RuboCop::AST::CollectionNode
851
+ end
852
+ class RuboCop::AST::ArrayNode < RuboCop::AST::Node
853
+ def bracketed?; end
854
+ def each_value(&block); end
855
+ def percent_literal?(type = nil); end
856
+ def square_brackets?; end
857
+ def values; end
858
+ end
859
+ class RuboCop::AST::BlockNode < RuboCop::AST::Node
860
+ def argument_list; end
861
+ def arguments; end
862
+ def arguments?; end
863
+ def body; end
864
+ def braces?; end
865
+ def closing_delimiter; end
866
+ def delimiters; end
867
+ def keywords?; end
868
+ def lambda?; end
869
+ def method_name; end
870
+ def multiline?; end
871
+ def numbered_arguments; end
872
+ def opening_delimiter; end
873
+ def send_node; end
874
+ def single_line?; end
875
+ def void_context?; end
876
+ include RuboCop::AST::MethodIdentifierPredicates
877
+ end
878
+ class RuboCop::AST::BreakNode < RuboCop::AST::Node
879
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
880
+ end
881
+ class RuboCop::AST::CaseMatchNode < RuboCop::AST::Node
882
+ def each_in_pattern(&block); end
883
+ def else?; end
884
+ def else_branch; end
885
+ def in_pattern_branches; end
886
+ def keyword; end
887
+ include RuboCop::AST::ConditionalNode
888
+ end
889
+ class RuboCop::AST::CaseNode < RuboCop::AST::Node
890
+ def branches; end
891
+ def each_when(&block); end
892
+ def else?; end
893
+ def else_branch; end
894
+ def keyword; end
895
+ def when_branches; end
896
+ include RuboCop::AST::ConditionalNode
897
+ end
898
+ class RuboCop::AST::ClassNode < RuboCop::AST::Node
899
+ def body; end
900
+ def identifier; end
901
+ def parent_class; end
902
+ end
903
+ class RuboCop::AST::ConstNode < RuboCop::AST::Node
904
+ def absolute?; end
905
+ def class_name?; end
906
+ def each_path(&block); end
907
+ def module_name?; end
908
+ def namespace; end
909
+ def relative?; end
910
+ def short_name; end
911
+ end
912
+ class RuboCop::AST::DefNode < RuboCop::AST::Node
913
+ def argument_forwarding?; end
914
+ def arguments; end
915
+ def body; end
916
+ def endless?; end
917
+ def method_name; end
918
+ def receiver; end
919
+ def void_context?; end
920
+ include RuboCop::AST::MethodIdentifierPredicates
921
+ include RuboCop::AST::ParameterizedNode
922
+ end
923
+ class RuboCop::AST::DefinedNode < RuboCop::AST::Node
924
+ def arguments; end
925
+ def node_parts; end
926
+ include RuboCop::AST::MethodDispatchNode
927
+ include RuboCop::AST::ParameterizedNode
928
+ end
929
+ class RuboCop::AST::EnsureNode < RuboCop::AST::Node
930
+ def body; end
931
+ end
932
+ class RuboCop::AST::ForNode < RuboCop::AST::Node
933
+ def body; end
934
+ def collection; end
935
+ def do?; end
936
+ def keyword; end
937
+ def variable; end
938
+ def void_context?; end
939
+ end
940
+ class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node
941
+ def to_a; end
942
+ include RuboCop::AST::CollectionNode
943
+ end
944
+ class RuboCop::AST::FloatNode < RuboCop::AST::Node
945
+ include RuboCop::AST::BasicLiteralNode
946
+ include RuboCop::AST::NumericNode
947
+ end
948
+ class RuboCop::AST::HashNode < RuboCop::AST::Node
949
+ def braces?; end
950
+ def each_key(&block); end
951
+ def each_pair; end
952
+ def each_value(&block); end
953
+ def empty?; end
954
+ def keys; end
955
+ def mixed_delimiters?; end
956
+ def pairs; end
957
+ def pairs_on_same_line?; end
958
+ def values; end
959
+ end
960
+ class RuboCop::AST::IfNode < RuboCop::AST::Node
961
+ def branches; end
962
+ def each_branch(&block); end
963
+ def else?; end
964
+ def else_branch; end
965
+ def elsif?; end
966
+ def elsif_conditional?; end
967
+ def if?; end
968
+ def if_branch; end
969
+ def inverse_keyword; end
970
+ def keyword; end
971
+ def modifier_form?; end
972
+ def nested_conditional?; end
973
+ def node_parts; end
974
+ def ternary?; end
975
+ def unless?; end
976
+ include RuboCop::AST::ConditionalNode
977
+ include RuboCop::AST::ModifierNode
978
+ end
979
+ class RuboCop::AST::IndexNode < RuboCop::AST::Node
980
+ def assignment_method?; end
981
+ def attribute_accessor?; end
982
+ def first_argument_index; end
983
+ def method_name; end
984
+ include RuboCop::AST::MethodDispatchNode
985
+ include RuboCop::AST::ParameterizedNode::RestArguments
986
+ end
987
+ class RuboCop::AST::IndexasgnNode < RuboCop::AST::Node
988
+ def assignment_method?; end
989
+ def attribute_accessor?; end
990
+ def first_argument_index; end
991
+ def method_name; end
992
+ include RuboCop::AST::MethodDispatchNode
993
+ include RuboCop::AST::ParameterizedNode::RestArguments
994
+ end
995
+ class RuboCop::AST::IntNode < RuboCop::AST::Node
996
+ include RuboCop::AST::BasicLiteralNode
997
+ include RuboCop::AST::NumericNode
998
+ end
999
+ class RuboCop::AST::KeywordSplatNode < RuboCop::AST::Node
1000
+ def colon?; end
1001
+ def hash_rocket?; end
1002
+ def node_parts; end
1003
+ def operator; end
1004
+ include RuboCop::AST::HashElementNode
1005
+ end
1006
+ class RuboCop::AST::LambdaNode < RuboCop::AST::Node
1007
+ def assignment_method?; end
1008
+ def attribute_accessor?; end
1009
+ def first_argument_index; end
1010
+ def lambda?; end
1011
+ def lambda_literal?; end
1012
+ def method_name; end
1013
+ def receiver; end
1014
+ include RuboCop::AST::MethodDispatchNode
1015
+ include RuboCop::AST::ParameterizedNode::RestArguments
1016
+ end
1017
+ class RuboCop::AST::ModuleNode < RuboCop::AST::Node
1018
+ def body; end
1019
+ def identifier; end
1020
+ end
1021
+ class RuboCop::AST::NextNode < RuboCop::AST::Node
1022
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
1023
+ end
1024
+ class RuboCop::AST::OrNode < RuboCop::AST::Node
1025
+ def alternate_operator; end
1026
+ def inverse_operator; end
1027
+ include RuboCop::AST::BinaryOperatorNode
1028
+ include RuboCop::AST::PredicateOperatorNode
1029
+ end
1030
+ class RuboCop::AST::PairNode < RuboCop::AST::Node
1031
+ def colon?; end
1032
+ def delimiter(*deprecated, with_spacing: nil); end
1033
+ def hash_rocket?; end
1034
+ def inverse_delimiter(*deprecated, with_spacing: nil); end
1035
+ def value_on_new_line?; end
1036
+ include RuboCop::AST::HashElementNode
1037
+ end
1038
+ class RuboCop::AST::Procarg0Node < RuboCop::AST::ArgNode
1039
+ def name; end
1040
+ end
1041
+ class RuboCop::AST::RangeNode < RuboCop::AST::Node
1042
+ def begin; end
1043
+ def end; end
1044
+ end
1045
+ class RuboCop::AST::RegexpNode < RuboCop::AST::Node
1046
+ def content; end
1047
+ def delimiter?(char); end
1048
+ def delimiters; end
1049
+ def extended?; end
1050
+ def ignore_case?; end
1051
+ def interpolation?; end
1052
+ def multiline_mode?; end
1053
+ def no_encoding?; end
1054
+ def options; end
1055
+ def percent_r_literal?; end
1056
+ def regopt; end
1057
+ def regopt_include?(option); end
1058
+ def single_interpolation?; end
1059
+ def slash_literal?; end
1060
+ def to_regexp; end
1061
+ end
1062
+ class RuboCop::AST::RescueNode < RuboCop::AST::Node
1063
+ def body; end
1064
+ def branches; end
1065
+ def else?; end
1066
+ def else_branch; end
1067
+ def resbody_branches; end
1068
+ end
1069
+ class RuboCop::AST::ResbodyNode < RuboCop::AST::Node
1070
+ def body; end
1071
+ def branch_index; end
1072
+ def exception_variable; end
1073
+ def exceptions; end
1074
+ end
1075
+ class RuboCop::AST::ReturnNode < RuboCop::AST::Node
1076
+ include RuboCop::AST::ParameterizedNode::WrappedArguments
1077
+ end
1078
+ class RuboCop::AST::SelfClassNode < RuboCop::AST::Node
1079
+ def body; end
1080
+ def identifier; end
1081
+ end
1082
+ class RuboCop::AST::SendNode < RuboCop::AST::Node
1083
+ def attribute_accessor?(param0 = nil); end
1084
+ def first_argument_index; end
1085
+ include RuboCop::AST::MethodDispatchNode
1086
+ include RuboCop::AST::ParameterizedNode::RestArguments
1087
+ end
1088
+ class RuboCop::AST::StrNode < RuboCop::AST::Node
1089
+ def heredoc?; end
1090
+ include RuboCop::AST::BasicLiteralNode
1091
+ end
1092
+ class RuboCop::AST::SuperNode < RuboCop::AST::Node
1093
+ def arguments; end
1094
+ def node_parts; end
1095
+ include RuboCop::AST::MethodDispatchNode
1096
+ include RuboCop::AST::ParameterizedNode
1097
+ end
1098
+ class RuboCop::AST::SymbolNode < RuboCop::AST::Node
1099
+ include RuboCop::AST::BasicLiteralNode
1100
+ end
1101
+ class RuboCop::AST::UntilNode < RuboCop::AST::Node
1102
+ def do?; end
1103
+ def inverse_keyword; end
1104
+ def keyword; end
1105
+ include RuboCop::AST::ConditionalNode
1106
+ include RuboCop::AST::ModifierNode
1107
+ end
1108
+ class RuboCop::AST::WhenNode < RuboCop::AST::Node
1109
+ def body; end
1110
+ def branch_index; end
1111
+ def conditions; end
1112
+ def each_condition(&block); end
1113
+ def then?; end
1114
+ end
1115
+ class RuboCop::AST::WhileNode < RuboCop::AST::Node
1116
+ def do?; end
1117
+ def inverse_keyword; end
1118
+ def keyword; end
1119
+ include RuboCop::AST::ConditionalNode
1120
+ include RuboCop::AST::ModifierNode
1121
+ end
1122
+ class RuboCop::AST::YieldNode < RuboCop::AST::Node
1123
+ def arguments; end
1124
+ def node_parts; end
1125
+ include RuboCop::AST::MethodDispatchNode
1126
+ include RuboCop::AST::ParameterizedNode
1127
+ end
1128
+ class RuboCop::AST::Builder < Parser::Builders::Default
1129
+ def n(type, children, source_map); end
1130
+ def node_klass(type); end
1131
+ def string_value(token); end
1132
+ end
1133
+ class RuboCop::AST::ProcessedSource
1134
+ def [](*args); end
1135
+ def ast; end
1136
+ def ast_with_comments; end
1137
+ def blank?; end
1138
+ def buffer; end
1139
+ def checksum; end
1140
+ def comment_at_line(line); end
1141
+ def comment_index; end
1142
+ def commented?(source_range); end
1143
+ def comments; end
1144
+ def comments_before_line(line); end
1145
+ def contains_comment?(source_range); end
1146
+ def create_parser(ruby_version); end
1147
+ def current_line(token); end
1148
+ def diagnostics; end
1149
+ def each_comment(&block); end
1150
+ def each_comment_in_lines(line_range); end
1151
+ def each_token(&block); end
1152
+ def file_path; end
1153
+ def find_comment(&block); end
1154
+ def find_token(&block); end
1155
+ def first_token_index(range_or_node); end
1156
+ def first_token_of(range_or_node); end
1157
+ def following_line(token); end
1158
+ def initialize(source, ruby_version, path = nil); end
1159
+ def last_token_index(range_or_node); end
1160
+ def last_token_of(range_or_node); end
1161
+ def line_indentation(line_number); end
1162
+ def line_with_comment?(line); end
1163
+ def lines; end
1164
+ def parse(source, ruby_version); end
1165
+ def parser_class(ruby_version); end
1166
+ def parser_error; end
1167
+ def path; end
1168
+ def preceding_line(token); end
1169
+ def raw_source; end
1170
+ def ruby_version; end
1171
+ def self.from_file(path, ruby_version); end
1172
+ def sorted_tokens; end
1173
+ def source_range(range_or_node); end
1174
+ def start_with?(string); end
1175
+ def tokenize(parser); end
1176
+ def tokens; end
1177
+ def tokens_within(range_or_node); end
1178
+ def valid_syntax?; end
1179
+ end
1180
+ module RuboCop::AST::RuboCopCompatibility
1181
+ def rubocop_loaded; end
1182
+ end
1183
+ class RuboCop::AST::Token
1184
+ def begin_pos; end
1185
+ def column; end
1186
+ def comma?; end
1187
+ def comment?; end
1188
+ def end?; end
1189
+ def end_pos; end
1190
+ def equal_sign?; end
1191
+ def initialize(pos, type, text); end
1192
+ def left_array_bracket?; end
1193
+ def left_brace?; end
1194
+ def left_bracket?; end
1195
+ def left_curly_brace?; end
1196
+ def left_parens?; end
1197
+ def left_ref_bracket?; end
1198
+ def line; end
1199
+ def pos; end
1200
+ def rescue_modifier?; end
1201
+ def right_bracket?; end
1202
+ def right_curly_brace?; end
1203
+ def right_parens?; end
1204
+ def self.from_parser_token(parser_token); end
1205
+ def semicolon?; end
1206
+ def space_after?; end
1207
+ def space_before?; end
1208
+ def text; end
1209
+ def to_s; end
1210
+ def type; end
1211
+ end
1212
+ module RuboCop::AST::Traversal
1213
+ def on___ENCODING__(node); end
1214
+ def on___FILE__(node); end
1215
+ def on___LINE__(node); end
1216
+ def on_alias(node); end
1217
+ def on_and(node); end
1218
+ def on_and_asgn(node); end
1219
+ def on_arg(node); end
1220
+ def on_arg_expr(node); end
1221
+ def on_args(node); end
1222
+ def on_array(node); end
1223
+ def on_array_pattern(node); end
1224
+ def on_array_pattern_with_tail(node); end
1225
+ def on_back_ref(node); end
1226
+ def on_begin(node); end
1227
+ def on_block(node); end
1228
+ def on_block_pass(node); end
1229
+ def on_blockarg(node); end
1230
+ def on_break(node); end
1231
+ def on_case(node); end
1232
+ def on_case_match(node); end
1233
+ def on_casgn(node); end
1234
+ def on_cbase(node); end
1235
+ def on_class(node); end
1236
+ def on_complex(node); end
1237
+ def on_const(node); end
1238
+ def on_const_pattern(node); end
1239
+ def on_csend(node); end
1240
+ def on_cvar(node); end
1241
+ def on_cvasgn(node); end
1242
+ def on_def(node); end
1243
+ def on_defined?(node); end
1244
+ def on_defs(node); end
1245
+ def on_dstr(node); end
1246
+ def on_dsym(node); end
1247
+ def on_eflipflop(node); end
1248
+ def on_empty_else(node); end
1249
+ def on_ensure(node); end
1250
+ def on_erange(node); end
1251
+ def on_false(node); end
1252
+ def on_find_pattern(node); end
1253
+ def on_float(node); end
1254
+ def on_for(node); end
1255
+ def on_forward_arg(node); end
1256
+ def on_forward_args(node); end
1257
+ def on_forwarded_args(node); end
1258
+ def on_gvar(node); end
1259
+ def on_gvasgn(node); end
1260
+ def on_hash(node); end
1261
+ def on_hash_pattern(node); end
1262
+ def on_if(node); end
1263
+ def on_if_guard(node); end
1264
+ def on_iflipflop(node); end
1265
+ def on_in_match(node); end
1266
+ def on_in_pattern(node); end
1267
+ def on_index(node); end
1268
+ def on_indexasgn(node); end
1269
+ def on_int(node); end
1270
+ def on_irange(node); end
1271
+ def on_ivar(node); end
1272
+ def on_ivasgn(node); end
1273
+ def on_kwarg(node); end
1274
+ def on_kwargs(node); end
1275
+ def on_kwbegin(node); end
1276
+ def on_kwnilarg(node); end
1277
+ def on_kwoptarg(node); end
1278
+ def on_kwrestarg(node); end
1279
+ def on_kwsplat(node); end
1280
+ def on_lambda(node); end
1281
+ def on_lvar(node); end
1282
+ def on_lvasgn(node); end
1283
+ def on_masgn(node); end
1284
+ def on_match_alt(node); end
1285
+ def on_match_as(node); end
1286
+ def on_match_current_line(node); end
1287
+ def on_match_nil_pattern(node); end
1288
+ def on_match_pattern(node); end
1289
+ def on_match_pattern_p(node); end
1290
+ def on_match_rest(node); end
1291
+ def on_match_var(node); end
1292
+ def on_match_with_lvasgn(node); end
1293
+ def on_match_with_trailing_comma(node); end
1294
+ def on_mlhs(node); end
1295
+ def on_module(node); end
1296
+ def on_mrasgn(node); end
1297
+ def on_next(node); end
1298
+ def on_nil(node); end
1299
+ def on_not(node); end
1300
+ def on_nth_ref(node); end
1301
+ def on_numblock(node); end
1302
+ def on_op_asgn(node); end
1303
+ def on_optarg(node); end
1304
+ def on_or(node); end
1305
+ def on_or_asgn(node); end
1306
+ def on_pair(node); end
1307
+ def on_pin(node); end
1308
+ def on_postexe(node); end
1309
+ def on_preexe(node); end
1310
+ def on_procarg0(node); end
1311
+ def on_rasgn(node); end
1312
+ def on_rational(node); end
1313
+ def on_redo(node); end
1314
+ def on_regexp(node); end
1315
+ def on_regopt(node); end
1316
+ def on_resbody(node); end
1317
+ def on_rescue(node); end
1318
+ def on_restarg(node); end
1319
+ def on_retry(node); end
1320
+ def on_return(node); end
1321
+ def on_sclass(node); end
1322
+ def on_self(node); end
1323
+ def on_send(node); end
1324
+ def on_shadowarg(node); end
1325
+ def on_splat(node); end
1326
+ def on_str(node); end
1327
+ def on_super(node); end
1328
+ def on_sym(node); end
1329
+ def on_true(node); end
1330
+ def on_undef(node); end
1331
+ def on_unless_guard(node); end
1332
+ def on_until(node); end
1333
+ def on_until_post(node); end
1334
+ def on_when(node); end
1335
+ def on_while(node); end
1336
+ def on_while_post(node); end
1337
+ def on_xstr(node); end
1338
+ def on_yield(node); end
1339
+ def on_zsuper(node); end
1340
+ def walk(node); end
1341
+ extend RuboCop::AST::Traversal::CallbackCompiler
1342
+ end
1343
+ class RuboCop::AST::Traversal::DebugError < RuntimeError
1344
+ end
1345
+ module RuboCop::AST::Traversal::CallbackCompiler
1346
+ def arity_check(range); end
1347
+ def body(signature, prelude); end
1348
+ def def_callback(type, *signature, arity: nil, arity_check: nil, body: nil); end
1349
+ end
1350
+ module RuboCop::AST::Version
1351
+ end