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,64 @@
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/method_source/all/method_source.rbi
9
+ #
10
+ # method_source-0.9.2
11
+
12
+ module MethodSource
13
+ def self.comment_helper(source_location, name = nil); end
14
+ def self.extract_code(source_location); end
15
+ def self.lines_for(file_name, name = nil); end
16
+ def self.source_helper(source_location, name = nil); end
17
+ def self.valid_expression?(str); end
18
+ extend MethodSource::CodeHelpers
19
+ end
20
+ module MethodSource::ReeSourceLocation
21
+ def source_location; end
22
+ end
23
+ module MethodSource::SourceLocation
24
+ end
25
+ module MethodSource::SourceLocation::MethodExtensions
26
+ def source_location; end
27
+ def trace_func(event, file, line, id, binding, classname); end
28
+ end
29
+ module MethodSource::SourceLocation::ProcExtensions
30
+ def source_location; end
31
+ end
32
+ module MethodSource::SourceLocation::UnboundMethodExtensions
33
+ def source_location; end
34
+ end
35
+ module MethodSource::CodeHelpers
36
+ def comment_describing(file, line_number); end
37
+ def complete_expression?(str); end
38
+ def expression_at(file, line_number, options = nil); end
39
+ def extract_first_expression(lines, consume = nil, &block); end
40
+ def extract_last_comment(lines); end
41
+ end
42
+ module MethodSource::CodeHelpers::IncompleteExpression
43
+ def self.===(ex); end
44
+ def self.rbx?; end
45
+ end
46
+ class MethodSource::SourceNotFoundError < StandardError
47
+ end
48
+ module MethodSource::MethodExtensions
49
+ def comment; end
50
+ def self.included(klass); end
51
+ def source; end
52
+ end
53
+ class Method
54
+ include MethodSource::MethodExtensions
55
+ include MethodSource::SourceLocation::MethodExtensions
56
+ end
57
+ class UnboundMethod
58
+ include MethodSource::MethodExtensions
59
+ include MethodSource::SourceLocation::UnboundMethodExtensions
60
+ end
61
+ class Proc
62
+ include MethodSource::MethodExtensions
63
+ include MethodSource::SourceLocation::ProcExtensions
64
+ end
@@ -0,0 +1,83 @@
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/parallel/all/parallel.rbi
9
+ #
10
+ # parallel-1.20.1
11
+
12
+ module Parallel
13
+ def self.add_progress_bar!(job_factory, options); end
14
+ def self.all?(*args, &block); end
15
+ def self.any?(*args, &block); end
16
+ def self.call_with_index(item, index, options, &block); end
17
+ def self.create_workers(job_factory, options, &block); end
18
+ def self.each(array, options = nil, &block); end
19
+ def self.each_with_index(array, options = nil, &block); end
20
+ def self.extract_count_from_options(options); end
21
+ def self.flat_map(*args, &block); end
22
+ def self.in_processes(options = nil, &block); end
23
+ def self.in_threads(options = nil); end
24
+ def self.map(source, options = nil, &block); end
25
+ def self.map_with_index(array, options = nil, &block); end
26
+ def self.process_incoming_jobs(read, write, job_factory, options, &block); end
27
+ def self.replace_worker(job_factory, workers, i, options, blk); end
28
+ def self.with_instrumentation(item, index, options); end
29
+ def self.work_direct(job_factory, options, &block); end
30
+ def self.work_in_processes(job_factory, options, &blk); end
31
+ def self.work_in_threads(job_factory, options, &block); end
32
+ def self.worker(job_factory, options, &block); end
33
+ def self.worker_number; end
34
+ def self.worker_number=(worker_num); end
35
+ extend Parallel::ProcessorCount
36
+ end
37
+ module Parallel::ProcessorCount
38
+ def physical_processor_count; end
39
+ def processor_count; end
40
+ end
41
+ class Parallel::DeadWorker < StandardError
42
+ end
43
+ class Parallel::Break < StandardError
44
+ def initialize(value = nil); end
45
+ def value; end
46
+ end
47
+ class Parallel::Kill < Parallel::Break
48
+ end
49
+ class Parallel::UndumpableException < StandardError
50
+ def backtrace; end
51
+ def initialize(original); end
52
+ end
53
+ class Parallel::ExceptionWrapper
54
+ def exception; end
55
+ def initialize(exception); end
56
+ end
57
+ class Parallel::Worker
58
+ def close_pipes; end
59
+ def initialize(read, write, pid); end
60
+ def pid; end
61
+ def read; end
62
+ def stop; end
63
+ def thread; end
64
+ def thread=(arg0); end
65
+ def wait; end
66
+ def work(data); end
67
+ def write; end
68
+ end
69
+ class Parallel::JobFactory
70
+ def initialize(source, mutex); end
71
+ def next; end
72
+ def pack(item, index); end
73
+ def producer?; end
74
+ def queue_wrapper(array); end
75
+ def size; end
76
+ def unpack(data); end
77
+ end
78
+ class Parallel::UserInterruptHandler
79
+ def self.kill(thing); end
80
+ def self.kill_on_ctrl_c(pids, options); end
81
+ def self.restore_interrupt(old, signal); end
82
+ def self.trap_interrupt(signal); end
83
+ end
@@ -0,0 +1,1510 @@
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/parser/all/parser.rbi
9
+ #
10
+ # parser-3.0.0.0
11
+
12
+ module Parser
13
+ def self.warn_syntax_deviation(feature, version); end
14
+ end
15
+ module Parser::Messages
16
+ def self.compile(reason, arguments); end
17
+ end
18
+ module Parser::Deprecation
19
+ def warn_of_deprecation; end
20
+ def warned_of_deprecation=(arg0); end
21
+ end
22
+ module Parser::AST
23
+ end
24
+ class Parser::AST::Node < AST::Node
25
+ def assign_properties(properties); end
26
+ def loc; end
27
+ def location; end
28
+ end
29
+ class Parser::AST::Processor < AST::Processor
30
+ def on_alias(node); end
31
+ def on_and(node); end
32
+ def on_and_asgn(node); end
33
+ def on_arg(node); end
34
+ def on_arg_expr(node); end
35
+ def on_args(node); end
36
+ def on_argument(node); end
37
+ def on_array(node); end
38
+ def on_array_pattern(node); end
39
+ def on_array_pattern_with_tail(node); end
40
+ def on_back_ref(node); end
41
+ def on_begin(node); end
42
+ def on_block(node); end
43
+ def on_block_pass(node); end
44
+ def on_blockarg(node); end
45
+ def on_blockarg_expr(node); end
46
+ def on_break(node); end
47
+ def on_case(node); end
48
+ def on_case_match(node); end
49
+ def on_casgn(node); end
50
+ def on_class(node); end
51
+ def on_const(node); end
52
+ def on_const_pattern(node); end
53
+ def on_csend(node); end
54
+ def on_cvar(node); end
55
+ def on_cvasgn(node); end
56
+ def on_def(node); end
57
+ def on_defined?(node); end
58
+ def on_defs(node); end
59
+ def on_dstr(node); end
60
+ def on_dsym(node); end
61
+ def on_eflipflop(node); end
62
+ def on_empty_else(node); end
63
+ def on_ensure(node); end
64
+ def on_erange(node); end
65
+ def on_find_pattern(node); end
66
+ def on_for(node); end
67
+ def on_forward_arg(node); end
68
+ def on_gvar(node); end
69
+ def on_gvasgn(node); end
70
+ def on_hash(node); end
71
+ def on_hash_pattern(node); end
72
+ def on_if(node); end
73
+ def on_if_guard(node); end
74
+ def on_iflipflop(node); end
75
+ def on_in_match(node); end
76
+ def on_in_pattern(node); end
77
+ def on_index(node); end
78
+ def on_indexasgn(node); end
79
+ def on_irange(node); end
80
+ def on_ivar(node); end
81
+ def on_ivasgn(node); end
82
+ def on_kwarg(node); end
83
+ def on_kwargs(node); end
84
+ def on_kwbegin(node); end
85
+ def on_kwoptarg(node); end
86
+ def on_kwrestarg(node); end
87
+ def on_kwsplat(node); end
88
+ def on_lambda(node); end
89
+ def on_lvar(node); end
90
+ def on_lvasgn(node); end
91
+ def on_masgn(node); end
92
+ def on_match_alt(node); end
93
+ def on_match_as(node); end
94
+ def on_match_current_line(node); end
95
+ def on_match_pattern(node); end
96
+ def on_match_pattern_p(node); end
97
+ def on_match_rest(node); end
98
+ def on_match_var(node); end
99
+ def on_match_with_lvasgn(node); end
100
+ def on_mlhs(node); end
101
+ def on_module(node); end
102
+ def on_next(node); end
103
+ def on_not(node); end
104
+ def on_nth_ref(node); end
105
+ def on_numblock(node); end
106
+ def on_op_asgn(node); end
107
+ def on_optarg(node); end
108
+ def on_or(node); end
109
+ def on_or_asgn(node); end
110
+ def on_pair(node); end
111
+ def on_pin(node); end
112
+ def on_postexe(node); end
113
+ def on_preexe(node); end
114
+ def on_procarg0(node); end
115
+ def on_redo(node); end
116
+ def on_regexp(node); end
117
+ def on_resbody(node); end
118
+ def on_rescue(node); end
119
+ def on_restarg(node); end
120
+ def on_restarg_expr(node); end
121
+ def on_retry(node); end
122
+ def on_return(node); end
123
+ def on_sclass(node); end
124
+ def on_send(node); end
125
+ def on_shadowarg(node); end
126
+ def on_splat(node); end
127
+ def on_super(node); end
128
+ def on_undef(node); end
129
+ def on_unless_guard(node); end
130
+ def on_until(node); end
131
+ def on_until_post(node); end
132
+ def on_var(node); end
133
+ def on_vasgn(node); end
134
+ def on_when(node); end
135
+ def on_while(node); end
136
+ def on_while_post(node); end
137
+ def on_xstr(node); end
138
+ def on_yield(node); end
139
+ def process_argument_node(node); end
140
+ def process_regular_node(node); end
141
+ def process_var_asgn_node(node); end
142
+ def process_variable_node(node); end
143
+ end
144
+ module Parser::Meta
145
+ end
146
+ module Parser::Source
147
+ end
148
+ class Parser::Source::Buffer
149
+ def bsearch(line_begins, position); end
150
+ def column_for_position(position); end
151
+ def decompose_position(position); end
152
+ def first_line; end
153
+ def freeze; end
154
+ def initialize(name, first_line = nil, source: nil); end
155
+ def last_line; end
156
+ def line_begins; end
157
+ def line_for_position(position); end
158
+ def line_index_for_position(position); end
159
+ def line_range(lineno); end
160
+ def name; end
161
+ def raw_source=(input); end
162
+ def read; end
163
+ def self.recognize_encoding(string); end
164
+ def self.reencode_string(input); end
165
+ def slice(range); end
166
+ def source; end
167
+ def source=(input); end
168
+ def source_line(lineno); end
169
+ def source_lines; end
170
+ def source_range; end
171
+ end
172
+ class Parser::Source::Range
173
+ def <=>(other); end
174
+ def adjust(begin_pos: nil, end_pos: nil); end
175
+ def begin; end
176
+ def begin_pos; end
177
+ def column; end
178
+ def column_range; end
179
+ def contained?(other); end
180
+ def contains?(other); end
181
+ def crossing?(other); end
182
+ def disjoint?(other); end
183
+ def empty?; end
184
+ def end; end
185
+ def end_pos; end
186
+ def eql?(arg0); end
187
+ def first_line; end
188
+ def hash; end
189
+ def initialize(source_buffer, begin_pos, end_pos); end
190
+ def inspect; end
191
+ def intersect(other); end
192
+ def is?(*what); end
193
+ def join(other); end
194
+ def last_column; end
195
+ def last_line; end
196
+ def length; end
197
+ def line; end
198
+ def overlaps?(other); end
199
+ def resize(new_size); end
200
+ def size; end
201
+ def source; end
202
+ def source_buffer; end
203
+ def source_line; end
204
+ def to_a; end
205
+ def to_range; end
206
+ def to_s; end
207
+ def with(begin_pos: nil, end_pos: nil); end
208
+ include Comparable
209
+ end
210
+ class Parser::Source::Comment
211
+ def ==(other); end
212
+ def document?; end
213
+ def initialize(range); end
214
+ def inline?; end
215
+ def inspect; end
216
+ def loc; end
217
+ def location; end
218
+ def self.associate(ast, comments); end
219
+ def self.associate_locations(ast, comments); end
220
+ def text; end
221
+ def type; end
222
+ end
223
+ class Parser::Source::Comment::Associator
224
+ def advance_comment; end
225
+ def advance_through_directives; end
226
+ def associate; end
227
+ def associate_and_advance_comment(node); end
228
+ def associate_locations; end
229
+ def children_in_source_order(node); end
230
+ def current_comment_before?(node); end
231
+ def current_comment_before_end?(node); end
232
+ def current_comment_decorates?(node); end
233
+ def do_associate; end
234
+ def initialize(ast, comments); end
235
+ def process_leading_comments(node); end
236
+ def process_trailing_comments(node); end
237
+ def skip_directives; end
238
+ def skip_directives=(arg0); end
239
+ def visit(node); end
240
+ end
241
+ class Parser::Source::Rewriter
242
+ def active_clobber; end
243
+ def active_clobber=(value); end
244
+ def active_insertions; end
245
+ def active_insertions=(value); end
246
+ def active_queue; end
247
+ def adjacent?(range1, range2); end
248
+ def adjacent_insertion_mask(range); end
249
+ def adjacent_insertions?(range); end
250
+ def adjacent_position_mask(range); end
251
+ def adjacent_updates?(range); end
252
+ def append(action); end
253
+ def can_merge?(action, existing); end
254
+ def clobbered_insertion?(insertion); end
255
+ def clobbered_position_mask(range); end
256
+ def diagnostics; end
257
+ def in_transaction?; end
258
+ def initialize(source_buffer); end
259
+ def insert_after(range, content); end
260
+ def insert_after_multi(range, content); end
261
+ def insert_before(range, content); end
262
+ def insert_before_multi(range, content); end
263
+ def merge_actions!(action, existing); end
264
+ def merge_actions(action, existing); end
265
+ def merge_replacements(actions); end
266
+ def process; end
267
+ def raise_clobber_error(action, existing); end
268
+ def record_insertion(range); end
269
+ def record_replace(range); end
270
+ def remove(range); end
271
+ def replace(range, content); end
272
+ def replace_actions(old, updated); end
273
+ def replace_compatible_with_insertion?(replace, insertion); end
274
+ def source_buffer; end
275
+ def transaction; end
276
+ def wrap(range, before, after); end
277
+ extend Parser::Deprecation
278
+ end
279
+ class Parser::Source::Rewriter::Action
280
+ def <=>(other); end
281
+ def allow_multiple_insertions; end
282
+ def allow_multiple_insertions?; end
283
+ def initialize(range, replacement = nil, allow_multiple_insertions = nil, order = nil); end
284
+ def order; end
285
+ def range; end
286
+ def replacement; end
287
+ def to_s; end
288
+ include Comparable
289
+ end
290
+ class Parser::Source::TreeRewriter
291
+ def action_root; end
292
+ def as_nested_actions; end
293
+ def as_replacements; end
294
+ def check_policy_validity; end
295
+ def check_range_validity(range); end
296
+ def combine(range, attributes); end
297
+ def diagnostics; end
298
+ def empty?; end
299
+ def enforce_policy(event); end
300
+ def import!(foreign_rewriter, offset: nil); end
301
+ def in_transaction?; end
302
+ def initialize(source_buffer, crossing_deletions: nil, different_replacements: nil, swallowed_insertions: nil); end
303
+ def insert_after(range, content); end
304
+ def insert_after_multi(range, text); end
305
+ def insert_before(range, content); end
306
+ def insert_before_multi(range, text); end
307
+ def merge!(with); end
308
+ def merge(with); end
309
+ def process; end
310
+ def remove(range); end
311
+ def replace(range, content); end
312
+ def source_buffer; end
313
+ def transaction; end
314
+ def trigger_policy(event, range: nil, conflict: nil, **arguments); end
315
+ def wrap(range, insert_before, insert_after); end
316
+ extend Parser::Deprecation
317
+ end
318
+ class Parser::Source::TreeRewriter::Action
319
+ def analyse_hierarchy(action); end
320
+ def bsearch_child_index(from = nil); end
321
+ def call_enforcer_for_merge(action); end
322
+ def check_fusible(action, *fusible); end
323
+ def children; end
324
+ def combine(action); end
325
+ def combine_children(more_children); end
326
+ def contract; end
327
+ def do_combine(action); end
328
+ def empty?; end
329
+ def fuse_deletions(action, fusible, other_sibblings); end
330
+ def initialize(range, enforcer, insert_before: nil, replacement: nil, insert_after: nil, children: nil); end
331
+ def insert_after; end
332
+ def insert_before; end
333
+ def insertion?; end
334
+ def merge(action); end
335
+ def moved(source_buffer, offset); end
336
+ def nested_actions; end
337
+ def ordered_replacements; end
338
+ def place_in_hierarchy(action); end
339
+ def range; end
340
+ def replacement; end
341
+ def swallow(children); end
342
+ def with(range: nil, enforcer: nil, children: nil, insert_before: nil, replacement: nil, insert_after: nil); end
343
+ end
344
+ class Parser::Source::Map
345
+ def ==(other); end
346
+ def column; end
347
+ def expression; end
348
+ def first_line; end
349
+ def initialize(expression); end
350
+ def initialize_copy(other); end
351
+ def last_column; end
352
+ def last_line; end
353
+ def line; end
354
+ def node; end
355
+ def node=(node); end
356
+ def to_hash; end
357
+ def update_expression(expression_l); end
358
+ def with(&block); end
359
+ def with_expression(expression_l); end
360
+ end
361
+ class Parser::Source::Map::Operator < Parser::Source::Map
362
+ def initialize(operator, expression); end
363
+ def operator; end
364
+ end
365
+ class Parser::Source::Map::Collection < Parser::Source::Map
366
+ def begin; end
367
+ def end; end
368
+ def initialize(begin_l, end_l, expression_l); end
369
+ end
370
+ class Parser::Source::Map::Constant < Parser::Source::Map
371
+ def double_colon; end
372
+ def initialize(double_colon, name, expression); end
373
+ def name; end
374
+ def operator; end
375
+ def update_operator(operator_l); end
376
+ def with_operator(operator_l); end
377
+ end
378
+ class Parser::Source::Map::Variable < Parser::Source::Map
379
+ def initialize(name_l, expression_l = nil); end
380
+ def name; end
381
+ def operator; end
382
+ def update_operator(operator_l); end
383
+ def with_operator(operator_l); end
384
+ end
385
+ class Parser::Source::Map::Keyword < Parser::Source::Map
386
+ def begin; end
387
+ def end; end
388
+ def initialize(keyword_l, begin_l, end_l, expression_l); end
389
+ def keyword; end
390
+ end
391
+ class Parser::Source::Map::Definition < Parser::Source::Map
392
+ def end; end
393
+ def initialize(keyword_l, operator_l, name_l, end_l); end
394
+ def keyword; end
395
+ def name; end
396
+ def operator; end
397
+ end
398
+ class Parser::Source::Map::MethodDefinition < Parser::Source::Map
399
+ def assignment; end
400
+ def end; end
401
+ def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
402
+ def keyword; end
403
+ def name; end
404
+ def operator; end
405
+ end
406
+ class Parser::Source::Map::Send < Parser::Source::Map
407
+ def begin; end
408
+ def dot; end
409
+ def end; end
410
+ def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
411
+ def operator; end
412
+ def selector; end
413
+ def update_operator(operator_l); end
414
+ def with_operator(operator_l); end
415
+ end
416
+ class Parser::Source::Map::Index < Parser::Source::Map
417
+ def begin; end
418
+ def end; end
419
+ def initialize(begin_l, end_l, expression_l); end
420
+ def operator; end
421
+ def update_operator(operator_l); end
422
+ def with_operator(operator_l); end
423
+ end
424
+ class Parser::Source::Map::Condition < Parser::Source::Map
425
+ def begin; end
426
+ def else; end
427
+ def end; end
428
+ def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
429
+ def keyword; end
430
+ end
431
+ class Parser::Source::Map::Ternary < Parser::Source::Map
432
+ def colon; end
433
+ def initialize(question_l, colon_l, expression_l); end
434
+ def question; end
435
+ end
436
+ class Parser::Source::Map::For < Parser::Source::Map
437
+ def begin; end
438
+ def end; end
439
+ def in; end
440
+ def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
441
+ def keyword; end
442
+ end
443
+ class Parser::Source::Map::RescueBody < Parser::Source::Map
444
+ def assoc; end
445
+ def begin; end
446
+ def initialize(keyword_l, assoc_l, begin_l, expression_l); end
447
+ def keyword; end
448
+ end
449
+ class Parser::Source::Map::Heredoc < Parser::Source::Map
450
+ def heredoc_body; end
451
+ def heredoc_end; end
452
+ def initialize(begin_l, body_l, end_l); end
453
+ end
454
+ class Parser::Source::Map::ObjcKwarg < Parser::Source::Map
455
+ def argument; end
456
+ def initialize(keyword_l, operator_l, argument_l, expression_l); end
457
+ def keyword; end
458
+ def operator; end
459
+ end
460
+ class Parser::SyntaxError < StandardError
461
+ def diagnostic; end
462
+ def initialize(diagnostic); end
463
+ end
464
+ class Parser::ClobberingError < RuntimeError
465
+ end
466
+ class Parser::Diagnostic
467
+ def arguments; end
468
+ def first_line_only(range); end
469
+ def highlights; end
470
+ def initialize(level, reason, arguments, location, highlights = nil); end
471
+ def last_line_only(range); end
472
+ def level; end
473
+ def location; end
474
+ def message; end
475
+ def reason; end
476
+ def render; end
477
+ def render_line(range, ellipsis = nil, range_end = nil); end
478
+ end
479
+ class Parser::Diagnostic::Engine
480
+ def all_errors_are_fatal; end
481
+ def all_errors_are_fatal=(arg0); end
482
+ def consumer; end
483
+ def consumer=(arg0); end
484
+ def ignore?(diagnostic); end
485
+ def ignore_warnings; end
486
+ def ignore_warnings=(arg0); end
487
+ def initialize(consumer = nil); end
488
+ def process(diagnostic); end
489
+ def raise?(diagnostic); end
490
+ end
491
+ class Parser::StaticEnvironment
492
+ def declare(name); end
493
+ def declare_forward_args; end
494
+ def declared?(name); end
495
+ def declared_forward_args?; end
496
+ def empty?; end
497
+ def extend_dynamic; end
498
+ def extend_static; end
499
+ def initialize; end
500
+ def reset; end
501
+ def unextend; end
502
+ end
503
+ class Parser::Lexer
504
+ def advance; end
505
+ def arg_or_cmdarg(cmd_state); end
506
+ def cmdarg; end
507
+ def cmdarg=(arg0); end
508
+ def cmdarg_stack; end
509
+ def command_start; end
510
+ def command_start=(arg0); end
511
+ def comments; end
512
+ def comments=(arg0); end
513
+ def cond; end
514
+ def cond=(arg0); end
515
+ def cond_stack; end
516
+ def context; end
517
+ def context=(arg0); end
518
+ def dedent_level; end
519
+ def diagnostic(type, reason, arguments = nil, location = nil, highlights = nil); end
520
+ def diagnostics; end
521
+ def diagnostics=(arg0); end
522
+ def emit(type, value = nil, s = nil, e = nil); end
523
+ def emit_comment(s = nil, e = nil); end
524
+ def emit_do(do_block = nil); end
525
+ def emit_table(table, s = nil, e = nil); end
526
+ def encode_escape(ord); end
527
+ def encoding; end
528
+ def eof_codepoint?(point); end
529
+ def force_utf32; end
530
+ def force_utf32=(arg0); end
531
+ def in_kwarg; end
532
+ def in_kwarg=(arg0); end
533
+ def initialize(version); end
534
+ def lambda_stack; end
535
+ def literal; end
536
+ def next_state_for_literal(literal); end
537
+ def paren_nest; end
538
+ def pop_cmdarg; end
539
+ def pop_cond; end
540
+ def pop_literal; end
541
+ def push_cmdarg; end
542
+ def push_cond; end
543
+ def push_literal(*args); end
544
+ def range(s = nil, e = nil); end
545
+ def reset(reset_state = nil); end
546
+ def self._lex_eof_trans; end
547
+ def self._lex_eof_trans=(arg0); end
548
+ def self._lex_from_state_actions; end
549
+ def self._lex_from_state_actions=(arg0); end
550
+ def self._lex_index_offsets; end
551
+ def self._lex_index_offsets=(arg0); end
552
+ def self._lex_indicies; end
553
+ def self._lex_indicies=(arg0); end
554
+ def self._lex_key_spans; end
555
+ def self._lex_key_spans=(arg0); end
556
+ def self._lex_to_state_actions; end
557
+ def self._lex_to_state_actions=(arg0); end
558
+ def self._lex_trans_actions; end
559
+ def self._lex_trans_actions=(arg0); end
560
+ def self._lex_trans_keys; end
561
+ def self._lex_trans_keys=(arg0); end
562
+ def self._lex_trans_targs; end
563
+ def self._lex_trans_targs=(arg0); end
564
+ def self.lex_en_expr_arg; end
565
+ def self.lex_en_expr_arg=(arg0); end
566
+ def self.lex_en_expr_beg; end
567
+ def self.lex_en_expr_beg=(arg0); end
568
+ def self.lex_en_expr_cmdarg; end
569
+ def self.lex_en_expr_cmdarg=(arg0); end
570
+ def self.lex_en_expr_dot; end
571
+ def self.lex_en_expr_dot=(arg0); end
572
+ def self.lex_en_expr_end; end
573
+ def self.lex_en_expr_end=(arg0); end
574
+ def self.lex_en_expr_endarg; end
575
+ def self.lex_en_expr_endarg=(arg0); end
576
+ def self.lex_en_expr_endfn; end
577
+ def self.lex_en_expr_endfn=(arg0); end
578
+ def self.lex_en_expr_fname; end
579
+ def self.lex_en_expr_fname=(arg0); end
580
+ def self.lex_en_expr_labelarg; end
581
+ def self.lex_en_expr_labelarg=(arg0); end
582
+ def self.lex_en_expr_mid; end
583
+ def self.lex_en_expr_mid=(arg0); end
584
+ def self.lex_en_expr_value; end
585
+ def self.lex_en_expr_value=(arg0); end
586
+ def self.lex_en_expr_variable; end
587
+ def self.lex_en_expr_variable=(arg0); end
588
+ def self.lex_en_interp_backslash_delimited; end
589
+ def self.lex_en_interp_backslash_delimited=(arg0); end
590
+ def self.lex_en_interp_backslash_delimited_words; end
591
+ def self.lex_en_interp_backslash_delimited_words=(arg0); end
592
+ def self.lex_en_interp_string; end
593
+ def self.lex_en_interp_string=(arg0); end
594
+ def self.lex_en_interp_words; end
595
+ def self.lex_en_interp_words=(arg0); end
596
+ def self.lex_en_leading_dot; end
597
+ def self.lex_en_leading_dot=(arg0); end
598
+ def self.lex_en_line_begin; end
599
+ def self.lex_en_line_begin=(arg0); end
600
+ def self.lex_en_line_comment; end
601
+ def self.lex_en_line_comment=(arg0); end
602
+ def self.lex_en_plain_backslash_delimited; end
603
+ def self.lex_en_plain_backslash_delimited=(arg0); end
604
+ def self.lex_en_plain_backslash_delimited_words; end
605
+ def self.lex_en_plain_backslash_delimited_words=(arg0); end
606
+ def self.lex_en_plain_string; end
607
+ def self.lex_en_plain_string=(arg0); end
608
+ def self.lex_en_plain_words; end
609
+ def self.lex_en_plain_words=(arg0); end
610
+ def self.lex_en_regexp_modifiers; end
611
+ def self.lex_en_regexp_modifiers=(arg0); end
612
+ def self.lex_error; end
613
+ def self.lex_error=(arg0); end
614
+ def self.lex_start; end
615
+ def self.lex_start=(arg0); end
616
+ def source_buffer; end
617
+ def source_buffer=(source_buffer); end
618
+ def stack_pop; end
619
+ def state; end
620
+ def state=(state); end
621
+ def static_env; end
622
+ def static_env=(arg0); end
623
+ def tok(s = nil, e = nil); end
624
+ def tokens; end
625
+ def tokens=(arg0); end
626
+ def version?(*versions); end
627
+ end
628
+ class Parser::Lexer::Literal
629
+ def backslash_delimited?; end
630
+ def clear_buffer; end
631
+ def coerce_encoding(string); end
632
+ def dedent_level; end
633
+ def delimiter?(delimiter); end
634
+ def emit(token, type, s, e); end
635
+ def emit_start_tok; end
636
+ def end_interp_brace_and_try_closing; end
637
+ def extend_content; end
638
+ def extend_space(ts, te); end
639
+ def extend_string(string, ts, te); end
640
+ def flush_string; end
641
+ def heredoc?; end
642
+ def heredoc_e; end
643
+ def infer_indent_level(line); end
644
+ def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = nil, dedent_body = nil, label_allowed = nil); end
645
+ def interpolate?; end
646
+ def munge_escape?(character); end
647
+ def nest_and_try_closing(delimiter, ts, te, lookahead = nil); end
648
+ def plain_heredoc?; end
649
+ def regexp?; end
650
+ def saved_herebody_s; end
651
+ def saved_herebody_s=(arg0); end
652
+ def squiggly_heredoc?; end
653
+ def start_interp_brace; end
654
+ def str_s; end
655
+ def supports_line_continuation_via_slash?; end
656
+ def type; end
657
+ def words?; end
658
+ end
659
+ class Parser::Lexer::StackState
660
+ def active?; end
661
+ def clear; end
662
+ def empty?; end
663
+ def initialize(name); end
664
+ def inspect; end
665
+ def lexpop; end
666
+ def pop; end
667
+ def push(bit); end
668
+ def to_s; end
669
+ end
670
+ class Parser::Lexer::Dedenter
671
+ def dedent(string); end
672
+ def initialize(dedent_level); end
673
+ def interrupt; end
674
+ end
675
+ class Parser::Builders::Default
676
+ def __ENCODING__(__ENCODING__t); end
677
+ def __FILE__(__FILE__t); end
678
+ def __LINE__(__LINE__t); end
679
+ def accessible(node); end
680
+ def alias(alias_t, to, from); end
681
+ def arg(name_t); end
682
+ def arg_expr(expr); end
683
+ def arg_name_collides?(this_name, that_name); end
684
+ def arg_prefix_map(op_t, name_t = nil); end
685
+ def args(begin_t, args, end_t, check_args = nil); end
686
+ def array(begin_t, elements, end_t); end
687
+ def array_pattern(lbrack_t, elements, rbrack_t); end
688
+ def assign(lhs, eql_t, rhs); end
689
+ def assignable(node); end
690
+ def associate(begin_t, pairs, end_t); end
691
+ def attr_asgn(receiver, dot_t, selector_t); end
692
+ def back_ref(token); end
693
+ def begin(begin_t, body, end_t); end
694
+ def begin_body(compound_stmt, rescue_bodies = nil, else_t = nil, else_ = nil, ensure_t = nil, ensure_ = nil); end
695
+ def begin_keyword(begin_t, body, end_t); end
696
+ def binary_op(receiver, operator_t, arg); end
697
+ def binary_op_map(left_e, op_t, right_e); end
698
+ def block(method_call, begin_t, args, body, end_t); end
699
+ def block_map(receiver_l, begin_t, end_t); end
700
+ def block_pass(amper_t, arg); end
701
+ def blockarg(amper_t, name_t); end
702
+ def blockarg_expr(amper_t, expr); end
703
+ def call_lambda(lambda_t); end
704
+ def call_method(receiver, dot_t, selector_t, lparen_t = nil, args = nil, rparen_t = nil); end
705
+ def call_type_for_dot(dot_t); end
706
+ def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
707
+ def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
708
+ def character(char_t); end
709
+ def check_assignment_to_numparam(name, loc); end
710
+ def check_condition(cond); end
711
+ def check_duplicate_arg(this_arg, map = nil); end
712
+ def check_duplicate_args(args, map = nil); end
713
+ def check_duplicate_pattern_key(name, loc); end
714
+ def check_duplicate_pattern_variable(name, loc); end
715
+ def check_lvar_name(name, loc); end
716
+ def check_reserved_for_numparam(name, loc); end
717
+ def collapse_string_parts?(parts); end
718
+ def collection_map(begin_t, parts, end_t); end
719
+ def complex(complex_t); end
720
+ def compstmt(statements); end
721
+ def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
722
+ def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
723
+ def condition_mod(if_true, if_false, cond_t, cond); end
724
+ def const(name_t); end
725
+ def const_fetch(scope, t_colon2, name_t); end
726
+ def const_global(t_colon3, name_t); end
727
+ def const_op_assignable(node); end
728
+ def const_pattern(const, ldelim_t, pattern, rdelim_t); end
729
+ def constant_map(scope, colon2_t, name_t); end
730
+ def cvar(token); end
731
+ def dedent_string(node, dedent_level); end
732
+ def def_class(class_t, name, lt_t, superclass, body, end_t); end
733
+ def def_endless_method(def_t, name_t, args, assignment_t, body); end
734
+ def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
735
+ def def_method(def_t, name_t, args, body, end_t); end
736
+ def def_module(module_t, name, body, end_t); end
737
+ def def_sclass(class_t, lshft_t, expr, body, end_t); end
738
+ def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
739
+ def definition_map(keyword_t, operator_t, name_t, end_t); end
740
+ def delimited_string_map(string_t); end
741
+ def diagnostic(type, reason, arguments, location, highlights = nil); end
742
+ def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
743
+ def emit_file_line_as_literals; end
744
+ def emit_file_line_as_literals=(arg0); end
745
+ def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
746
+ def expr_map(loc); end
747
+ def false(false_t); end
748
+ def find_pattern(lbrack_t, elements, rbrack_t); end
749
+ def float(float_t); end
750
+ def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
751
+ def for_map(keyword_t, in_t, begin_t, end_t); end
752
+ def forward_arg(dots_t); end
753
+ def forward_only_args(begin_t, dots_t, end_t); end
754
+ def forwarded_args(dots_t); end
755
+ def guard_map(keyword_t, guard_body_e); end
756
+ def gvar(token); end
757
+ def hash_pattern(lbrace_t, kwargs, rbrace_t); end
758
+ def ident(token); end
759
+ def if_guard(if_t, if_body); end
760
+ def in_match(lhs, in_t, rhs); end
761
+ def in_pattern(in_t, pattern, guard, then_t, body); end
762
+ def index(receiver, lbrack_t, indexes, rbrack_t); end
763
+ def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
764
+ def index_map(receiver_e, lbrack_t, rbrack_t); end
765
+ def initialize; end
766
+ def integer(integer_t); end
767
+ def ivar(token); end
768
+ def join_exprs(left_expr, right_expr); end
769
+ def keyword_cmd(type, keyword_t, lparen_t = nil, args = nil, rparen_t = nil); end
770
+ def keyword_map(keyword_t, begin_t, args, end_t); end
771
+ def keyword_mod_map(pre_e, keyword_t, post_e); end
772
+ def kwarg(name_t); end
773
+ def kwarg_map(name_t, value_e = nil); end
774
+ def kwargs?(node); end
775
+ def kwnilarg(dstar_t, nil_t); end
776
+ def kwoptarg(name_t, value); end
777
+ def kwrestarg(dstar_t, name_t = nil); end
778
+ def kwsplat(dstar_t, arg); end
779
+ def loc(token); end
780
+ def logical_op(type, lhs, op_t, rhs); end
781
+ def loop(type, keyword_t, cond, do_t, body, end_t); end
782
+ def loop_mod(type, body, keyword_t, cond); end
783
+ def match_alt(left, pipe_t, right); end
784
+ def match_as(value, assoc_t, as); end
785
+ def match_hash_var(name_t); end
786
+ def match_hash_var_from_str(begin_t, strings, end_t); end
787
+ def match_label(label_type, label); end
788
+ def match_nil_pattern(dstar_t, nil_t); end
789
+ def match_op(receiver, match_t, arg); end
790
+ def match_pair(label_type, label, value); end
791
+ def match_pattern(lhs, match_t, rhs); end
792
+ def match_pattern_p(lhs, match_t, rhs); end
793
+ def match_rest(star_t, name_t = nil); end
794
+ def match_var(name_t); end
795
+ def match_with_trailing_comma(match, comma_t); end
796
+ def module_definition_map(keyword_t, name_e, operator_t, end_t); end
797
+ def multi_assign(lhs, eql_t, rhs); end
798
+ def multi_lhs(begin_t, items, end_t); end
799
+ def n(type, children, source_map); end
800
+ def n0(type, source_map); end
801
+ def nil(nil_t); end
802
+ def not_op(not_t, begin_t = nil, receiver = nil, end_t = nil); end
803
+ def nth_ref(token); end
804
+ def numargs(max_numparam); end
805
+ def numeric(kind, token); end
806
+ def objc_kwarg(kwname_t, assoc_t, name_t); end
807
+ def objc_restarg(star_t, name = nil); end
808
+ def objc_varargs(pair, rest_of_varargs); end
809
+ def op_assign(lhs, op_t, rhs); end
810
+ def optarg(name_t, eql_t, value); end
811
+ def pair(key, assoc_t, value); end
812
+ def pair_keyword(key_t, value); end
813
+ def pair_keyword_map(key_t, value_e); end
814
+ def pair_list_18(list); end
815
+ def pair_quoted(begin_t, parts, end_t, value); end
816
+ def pair_quoted_map(begin_t, end_t, value_e); end
817
+ def parser; end
818
+ def parser=(arg0); end
819
+ def pin(pin_t, var); end
820
+ def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
821
+ def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
822
+ def prefix_string_map(symbol); end
823
+ def procarg0(arg); end
824
+ def range_exclusive(lhs, dot3_t, rhs); end
825
+ def range_inclusive(lhs, dot2_t, rhs); end
826
+ def range_map(start_e, op_t, end_e); end
827
+ def rational(rational_t); end
828
+ def regexp_compose(begin_t, parts, end_t, options); end
829
+ def regexp_map(begin_t, end_t, options_e); end
830
+ def regexp_options(regopt_t); end
831
+ def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
832
+ def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
833
+ def restarg(star_t, name_t = nil); end
834
+ def restarg_expr(star_t, expr = nil); end
835
+ def rewrite_hash_args_to_kwargs(args); end
836
+ def self(token); end
837
+ def self.emit_arg_inside_procarg0; end
838
+ def self.emit_arg_inside_procarg0=(arg0); end
839
+ def self.emit_encoding; end
840
+ def self.emit_encoding=(arg0); end
841
+ def self.emit_forward_arg; end
842
+ def self.emit_forward_arg=(arg0); end
843
+ def self.emit_index; end
844
+ def self.emit_index=(arg0); end
845
+ def self.emit_kwargs; end
846
+ def self.emit_kwargs=(arg0); end
847
+ def self.emit_lambda; end
848
+ def self.emit_lambda=(arg0); end
849
+ def self.emit_match_pattern; end
850
+ def self.emit_match_pattern=(arg0); end
851
+ def self.emit_procarg0; end
852
+ def self.emit_procarg0=(arg0); end
853
+ def self.modernize; end
854
+ def send_binary_op_map(lhs_e, selector_t, rhs_e); end
855
+ def send_index_map(receiver_e, lbrack_t, rbrack_t); end
856
+ def send_map(receiver_e, dot_t, selector_t, begin_t = nil, args = nil, end_t = nil); end
857
+ def send_unary_op_map(selector_t, arg_e); end
858
+ def shadowarg(name_t); end
859
+ def splat(star_t, arg = nil); end
860
+ def static_regexp(parts, options); end
861
+ def static_regexp_node(node); end
862
+ def static_string(nodes); end
863
+ def string(string_t); end
864
+ def string_compose(begin_t, parts, end_t); end
865
+ def string_internal(string_t); end
866
+ def string_map(begin_t, parts, end_t); end
867
+ def string_value(token); end
868
+ def symbol(symbol_t); end
869
+ def symbol_compose(begin_t, parts, end_t); end
870
+ def symbol_internal(symbol_t); end
871
+ def symbols_compose(begin_t, parts, end_t); end
872
+ def ternary(cond, question_t, if_true, colon_t, if_false); end
873
+ def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
874
+ def token_map(token); end
875
+ def true(true_t); end
876
+ def unary_num(unary_t, numeric); end
877
+ def unary_op(op_t, receiver); end
878
+ def unary_op_map(op_t, arg_e = nil); end
879
+ def undef_method(undef_t, names); end
880
+ def unless_guard(unless_t, unless_body); end
881
+ def unquoted_map(token); end
882
+ def validate_definee(definee); end
883
+ def value(token); end
884
+ def var_send_map(variable_e); end
885
+ def variable_map(name_t); end
886
+ def when(when_t, patterns, then_t, body); end
887
+ def word(parts); end
888
+ def words_compose(begin_t, parts, end_t); end
889
+ def xstring_compose(begin_t, parts, end_t); end
890
+ end
891
+ class Parser::Context
892
+ def class_definition_allowed?; end
893
+ def dynamic_const_definition_allowed?; end
894
+ def empty?; end
895
+ def in_block?; end
896
+ def in_class?; end
897
+ def in_dynamic_block?; end
898
+ def in_lambda?; end
899
+ def indirectly_in_def?; end
900
+ def initialize; end
901
+ def module_definition_allowed?; end
902
+ def pop; end
903
+ def push(state); end
904
+ def reset; end
905
+ def stack; end
906
+ end
907
+ class Parser::MaxNumparamStack
908
+ def empty?; end
909
+ def has_numparams?; end
910
+ def has_ordinary_params!; end
911
+ def has_ordinary_params?; end
912
+ def initialize; end
913
+ def pop; end
914
+ def push; end
915
+ def register(numparam); end
916
+ def set(value); end
917
+ def stack; end
918
+ def top; end
919
+ end
920
+ class Parser::CurrentArgStack
921
+ def empty?; end
922
+ def initialize; end
923
+ def pop; end
924
+ def push(value); end
925
+ def reset; end
926
+ def set(value); end
927
+ def stack; end
928
+ def top; end
929
+ end
930
+ class Parser::VariablesStack
931
+ def declare(name); end
932
+ def declared?(name); end
933
+ def empty?; end
934
+ def initialize; end
935
+ def pop; end
936
+ def push; end
937
+ def reset; end
938
+ end
939
+ class Parser::Base < Racc::Parser
940
+ def builder; end
941
+ def check_kwarg_name(name_t); end
942
+ def context; end
943
+ def current_arg_stack; end
944
+ def diagnostic(level, reason, arguments, location_t, highlights_ts = nil); end
945
+ def diagnostics; end
946
+ def initialize(builder = nil); end
947
+ def lexer; end
948
+ def max_numparam_stack; end
949
+ def next_token; end
950
+ def on_error(error_token_id, error_value, value_stack); end
951
+ def parse(source_buffer); end
952
+ def parse_with_comments(source_buffer); end
953
+ def pattern_hash_keys; end
954
+ def pattern_variables; end
955
+ def reset; end
956
+ def self.default_parser; end
957
+ def self.parse(string, file = nil, line = nil); end
958
+ def self.parse_file(filename); end
959
+ def self.parse_file_with_comments(filename); end
960
+ def self.parse_with_comments(string, file = nil, line = nil); end
961
+ def self.setup_source_buffer(file, line, string, encoding); end
962
+ def source_buffer; end
963
+ def static_env; end
964
+ def tokenize(source_buffer, recover = nil); end
965
+ end
966
+ class Parser::Rewriter < Parser::AST::Processor
967
+ def assignment?(node); end
968
+ def initialize(*arg0); end
969
+ def insert_after(range, content); end
970
+ def insert_before(range, content); end
971
+ def remove(range); end
972
+ def replace(range, content); end
973
+ def rewrite(source_buffer, ast); end
974
+ def wrap(range, before, after); end
975
+ extend Parser::Deprecation
976
+ end
977
+ class Parser::TreeRewriter < Parser::AST::Processor
978
+ def assignment?(node); end
979
+ def insert_after(range, content); end
980
+ def insert_before(range, content); end
981
+ def remove(range); end
982
+ def replace(range, content); end
983
+ def rewrite(source_buffer, ast, **policy); end
984
+ def wrap(range, before, after); end
985
+ end
986
+ module Parser::Builders
987
+ end
988
+ class Parser::Ruby27 < Parser::Base
989
+ def _reduce_1(val, _values, result); end
990
+ def _reduce_10(val, _values, result); end
991
+ def _reduce_100(val, _values, result); end
992
+ def _reduce_101(val, _values, result); end
993
+ def _reduce_102(val, _values, result); end
994
+ def _reduce_103(val, _values, result); end
995
+ def _reduce_104(val, _values, result); end
996
+ def _reduce_105(val, _values, result); end
997
+ def _reduce_106(val, _values, result); end
998
+ def _reduce_107(val, _values, result); end
999
+ def _reduce_108(val, _values, result); end
1000
+ def _reduce_109(val, _values, result); end
1001
+ def _reduce_11(val, _values, result); end
1002
+ def _reduce_110(val, _values, result); end
1003
+ def _reduce_111(val, _values, result); end
1004
+ def _reduce_112(val, _values, result); end
1005
+ def _reduce_113(val, _values, result); end
1006
+ def _reduce_114(val, _values, result); end
1007
+ def _reduce_115(val, _values, result); end
1008
+ def _reduce_117(val, _values, result); end
1009
+ def _reduce_118(val, _values, result); end
1010
+ def _reduce_119(val, _values, result); end
1011
+ def _reduce_12(val, _values, result); end
1012
+ def _reduce_125(val, _values, result); end
1013
+ def _reduce_127(val, _values, result); end
1014
+ def _reduce_128(val, _values, result); end
1015
+ def _reduce_129(val, _values, result); end
1016
+ def _reduce_13(val, _values, result); end
1017
+ def _reduce_14(val, _values, result); end
1018
+ def _reduce_15(val, _values, result); end
1019
+ def _reduce_16(val, _values, result); end
1020
+ def _reduce_18(val, _values, result); end
1021
+ def _reduce_19(val, _values, result); end
1022
+ def _reduce_2(val, _values, result); end
1023
+ def _reduce_20(val, _values, result); end
1024
+ def _reduce_201(val, _values, result); end
1025
+ def _reduce_202(val, _values, result); end
1026
+ def _reduce_203(val, _values, result); end
1027
+ def _reduce_204(val, _values, result); end
1028
+ def _reduce_205(val, _values, result); end
1029
+ def _reduce_206(val, _values, result); end
1030
+ def _reduce_207(val, _values, result); end
1031
+ def _reduce_208(val, _values, result); end
1032
+ def _reduce_209(val, _values, result); end
1033
+ def _reduce_21(val, _values, result); end
1034
+ def _reduce_210(val, _values, result); end
1035
+ def _reduce_211(val, _values, result); end
1036
+ def _reduce_212(val, _values, result); end
1037
+ def _reduce_213(val, _values, result); end
1038
+ def _reduce_214(val, _values, result); end
1039
+ def _reduce_215(val, _values, result); end
1040
+ def _reduce_216(val, _values, result); end
1041
+ def _reduce_217(val, _values, result); end
1042
+ def _reduce_218(val, _values, result); end
1043
+ def _reduce_219(val, _values, result); end
1044
+ def _reduce_22(val, _values, result); end
1045
+ def _reduce_220(val, _values, result); end
1046
+ def _reduce_221(val, _values, result); end
1047
+ def _reduce_222(val, _values, result); end
1048
+ def _reduce_223(val, _values, result); end
1049
+ def _reduce_224(val, _values, result); end
1050
+ def _reduce_225(val, _values, result); end
1051
+ def _reduce_226(val, _values, result); end
1052
+ def _reduce_227(val, _values, result); end
1053
+ def _reduce_228(val, _values, result); end
1054
+ def _reduce_23(val, _values, result); end
1055
+ def _reduce_230(val, _values, result); end
1056
+ def _reduce_231(val, _values, result); end
1057
+ def _reduce_232(val, _values, result); end
1058
+ def _reduce_233(val, _values, result); end
1059
+ def _reduce_234(val, _values, result); end
1060
+ def _reduce_235(val, _values, result); end
1061
+ def _reduce_236(val, _values, result); end
1062
+ def _reduce_237(val, _values, result); end
1063
+ def _reduce_238(val, _values, result); end
1064
+ def _reduce_239(val, _values, result); end
1065
+ def _reduce_24(val, _values, result); end
1066
+ def _reduce_240(val, _values, result); end
1067
+ def _reduce_241(val, _values, result); end
1068
+ def _reduce_242(val, _values, result); end
1069
+ def _reduce_248(val, _values, result); end
1070
+ def _reduce_249(val, _values, result); end
1071
+ def _reduce_25(val, _values, result); end
1072
+ def _reduce_253(val, _values, result); end
1073
+ def _reduce_254(val, _values, result); end
1074
+ def _reduce_256(val, _values, result); end
1075
+ def _reduce_257(val, _values, result); end
1076
+ def _reduce_258(val, _values, result); end
1077
+ def _reduce_259(val, _values, result); end
1078
+ def _reduce_26(val, _values, result); end
1079
+ def _reduce_261(val, _values, result); end
1080
+ def _reduce_264(val, _values, result); end
1081
+ def _reduce_265(val, _values, result); end
1082
+ def _reduce_266(val, _values, result); end
1083
+ def _reduce_267(val, _values, result); end
1084
+ def _reduce_268(val, _values, result); end
1085
+ def _reduce_269(val, _values, result); end
1086
+ def _reduce_27(val, _values, result); end
1087
+ def _reduce_270(val, _values, result); end
1088
+ def _reduce_271(val, _values, result); end
1089
+ def _reduce_272(val, _values, result); end
1090
+ def _reduce_273(val, _values, result); end
1091
+ def _reduce_274(val, _values, result); end
1092
+ def _reduce_275(val, _values, result); end
1093
+ def _reduce_276(val, _values, result); end
1094
+ def _reduce_277(val, _values, result); end
1095
+ def _reduce_278(val, _values, result); end
1096
+ def _reduce_279(val, _values, result); end
1097
+ def _reduce_28(val, _values, result); end
1098
+ def _reduce_280(val, _values, result); end
1099
+ def _reduce_282(val, _values, result); end
1100
+ def _reduce_283(val, _values, result); end
1101
+ def _reduce_284(val, _values, result); end
1102
+ def _reduce_29(val, _values, result); end
1103
+ def _reduce_295(val, _values, result); end
1104
+ def _reduce_296(val, _values, result); end
1105
+ def _reduce_297(val, _values, result); end
1106
+ def _reduce_298(val, _values, result); end
1107
+ def _reduce_299(val, _values, result); end
1108
+ def _reduce_3(val, _values, result); end
1109
+ def _reduce_30(val, _values, result); end
1110
+ def _reduce_300(val, _values, result); end
1111
+ def _reduce_301(val, _values, result); end
1112
+ def _reduce_302(val, _values, result); end
1113
+ def _reduce_303(val, _values, result); end
1114
+ def _reduce_304(val, _values, result); end
1115
+ def _reduce_305(val, _values, result); end
1116
+ def _reduce_306(val, _values, result); end
1117
+ def _reduce_307(val, _values, result); end
1118
+ def _reduce_308(val, _values, result); end
1119
+ def _reduce_309(val, _values, result); end
1120
+ def _reduce_310(val, _values, result); end
1121
+ def _reduce_311(val, _values, result); end
1122
+ def _reduce_312(val, _values, result); end
1123
+ def _reduce_313(val, _values, result); end
1124
+ def _reduce_314(val, _values, result); end
1125
+ def _reduce_316(val, _values, result); end
1126
+ def _reduce_317(val, _values, result); end
1127
+ def _reduce_318(val, _values, result); end
1128
+ def _reduce_319(val, _values, result); end
1129
+ def _reduce_32(val, _values, result); end
1130
+ def _reduce_320(val, _values, result); end
1131
+ def _reduce_321(val, _values, result); end
1132
+ def _reduce_322(val, _values, result); end
1133
+ def _reduce_323(val, _values, result); end
1134
+ def _reduce_324(val, _values, result); end
1135
+ def _reduce_325(val, _values, result); end
1136
+ def _reduce_326(val, _values, result); end
1137
+ def _reduce_327(val, _values, result); end
1138
+ def _reduce_328(val, _values, result); end
1139
+ def _reduce_329(val, _values, result); end
1140
+ def _reduce_33(val, _values, result); end
1141
+ def _reduce_330(val, _values, result); end
1142
+ def _reduce_331(val, _values, result); end
1143
+ def _reduce_332(val, _values, result); end
1144
+ def _reduce_333(val, _values, result); end
1145
+ def _reduce_334(val, _values, result); end
1146
+ def _reduce_335(val, _values, result); end
1147
+ def _reduce_336(val, _values, result); end
1148
+ def _reduce_337(val, _values, result); end
1149
+ def _reduce_338(val, _values, result); end
1150
+ def _reduce_339(val, _values, result); end
1151
+ def _reduce_34(val, _values, result); end
1152
+ def _reduce_340(val, _values, result); end
1153
+ def _reduce_341(val, _values, result); end
1154
+ def _reduce_343(val, _values, result); end
1155
+ def _reduce_346(val, _values, result); end
1156
+ def _reduce_35(val, _values, result); end
1157
+ def _reduce_350(val, _values, result); end
1158
+ def _reduce_352(val, _values, result); end
1159
+ def _reduce_355(val, _values, result); end
1160
+ def _reduce_356(val, _values, result); end
1161
+ def _reduce_357(val, _values, result); end
1162
+ def _reduce_358(val, _values, result); end
1163
+ def _reduce_360(val, _values, result); end
1164
+ def _reduce_361(val, _values, result); end
1165
+ def _reduce_362(val, _values, result); end
1166
+ def _reduce_363(val, _values, result); end
1167
+ def _reduce_364(val, _values, result); end
1168
+ def _reduce_365(val, _values, result); end
1169
+ def _reduce_366(val, _values, result); end
1170
+ def _reduce_367(val, _values, result); end
1171
+ def _reduce_368(val, _values, result); end
1172
+ def _reduce_369(val, _values, result); end
1173
+ def _reduce_37(val, _values, result); end
1174
+ def _reduce_370(val, _values, result); end
1175
+ def _reduce_371(val, _values, result); end
1176
+ def _reduce_372(val, _values, result); end
1177
+ def _reduce_373(val, _values, result); end
1178
+ def _reduce_374(val, _values, result); end
1179
+ def _reduce_375(val, _values, result); end
1180
+ def _reduce_376(val, _values, result); end
1181
+ def _reduce_377(val, _values, result); end
1182
+ def _reduce_379(val, _values, result); end
1183
+ def _reduce_38(val, _values, result); end
1184
+ def _reduce_380(val, _values, result); end
1185
+ def _reduce_381(val, _values, result); end
1186
+ def _reduce_382(val, _values, result); end
1187
+ def _reduce_383(val, _values, result); end
1188
+ def _reduce_384(val, _values, result); end
1189
+ def _reduce_385(val, _values, result); end
1190
+ def _reduce_386(val, _values, result); end
1191
+ def _reduce_388(val, _values, result); end
1192
+ def _reduce_389(val, _values, result); end
1193
+ def _reduce_39(val, _values, result); end
1194
+ def _reduce_390(val, _values, result); end
1195
+ def _reduce_391(val, _values, result); end
1196
+ def _reduce_392(val, _values, result); end
1197
+ def _reduce_393(val, _values, result); end
1198
+ def _reduce_394(val, _values, result); end
1199
+ def _reduce_395(val, _values, result); end
1200
+ def _reduce_396(val, _values, result); end
1201
+ def _reduce_398(val, _values, result); end
1202
+ def _reduce_399(val, _values, result); end
1203
+ def _reduce_4(val, _values, result); end
1204
+ def _reduce_40(val, _values, result); end
1205
+ def _reduce_400(val, _values, result); end
1206
+ def _reduce_401(val, _values, result); end
1207
+ def _reduce_402(val, _values, result); end
1208
+ def _reduce_403(val, _values, result); end
1209
+ def _reduce_404(val, _values, result); end
1210
+ def _reduce_405(val, _values, result); end
1211
+ def _reduce_406(val, _values, result); end
1212
+ def _reduce_407(val, _values, result); end
1213
+ def _reduce_408(val, _values, result); end
1214
+ def _reduce_409(val, _values, result); end
1215
+ def _reduce_41(val, _values, result); end
1216
+ def _reduce_410(val, _values, result); end
1217
+ def _reduce_411(val, _values, result); end
1218
+ def _reduce_412(val, _values, result); end
1219
+ def _reduce_413(val, _values, result); end
1220
+ def _reduce_414(val, _values, result); end
1221
+ def _reduce_415(val, _values, result); end
1222
+ def _reduce_416(val, _values, result); end
1223
+ def _reduce_417(val, _values, result); end
1224
+ def _reduce_418(val, _values, result); end
1225
+ def _reduce_419(val, _values, result); end
1226
+ def _reduce_42(val, _values, result); end
1227
+ def _reduce_420(val, _values, result); end
1228
+ def _reduce_421(val, _values, result); end
1229
+ def _reduce_422(val, _values, result); end
1230
+ def _reduce_423(val, _values, result); end
1231
+ def _reduce_424(val, _values, result); end
1232
+ def _reduce_425(val, _values, result); end
1233
+ def _reduce_426(val, _values, result); end
1234
+ def _reduce_427(val, _values, result); end
1235
+ def _reduce_428(val, _values, result); end
1236
+ def _reduce_429(val, _values, result); end
1237
+ def _reduce_43(val, _values, result); end
1238
+ def _reduce_430(val, _values, result); end
1239
+ def _reduce_431(val, _values, result); end
1240
+ def _reduce_432(val, _values, result); end
1241
+ def _reduce_434(val, _values, result); end
1242
+ def _reduce_435(val, _values, result); end
1243
+ def _reduce_436(val, _values, result); end
1244
+ def _reduce_437(val, _values, result); end
1245
+ def _reduce_439(val, _values, result); end
1246
+ def _reduce_44(val, _values, result); end
1247
+ def _reduce_440(val, _values, result); end
1248
+ def _reduce_441(val, _values, result); end
1249
+ def _reduce_443(val, _values, result); end
1250
+ def _reduce_444(val, _values, result); end
1251
+ def _reduce_445(val, _values, result); end
1252
+ def _reduce_446(val, _values, result); end
1253
+ def _reduce_448(val, _values, result); end
1254
+ def _reduce_450(val, _values, result); end
1255
+ def _reduce_452(val, _values, result); end
1256
+ def _reduce_453(val, _values, result); end
1257
+ def _reduce_455(val, _values, result); end
1258
+ def _reduce_456(val, _values, result); end
1259
+ def _reduce_457(val, _values, result); end
1260
+ def _reduce_458(val, _values, result); end
1261
+ def _reduce_459(val, _values, result); end
1262
+ def _reduce_46(val, _values, result); end
1263
+ def _reduce_460(val, _values, result); end
1264
+ def _reduce_461(val, _values, result); end
1265
+ def _reduce_462(val, _values, result); end
1266
+ def _reduce_463(val, _values, result); end
1267
+ def _reduce_464(val, _values, result); end
1268
+ def _reduce_465(val, _values, result); end
1269
+ def _reduce_466(val, _values, result); end
1270
+ def _reduce_467(val, _values, result); end
1271
+ def _reduce_468(val, _values, result); end
1272
+ def _reduce_469(val, _values, result); end
1273
+ def _reduce_470(val, _values, result); end
1274
+ def _reduce_471(val, _values, result); end
1275
+ def _reduce_472(val, _values, result); end
1276
+ def _reduce_473(val, _values, result); end
1277
+ def _reduce_474(val, _values, result); end
1278
+ def _reduce_475(val, _values, result); end
1279
+ def _reduce_477(val, _values, result); end
1280
+ def _reduce_478(val, _values, result); end
1281
+ def _reduce_479(val, _values, result); end
1282
+ def _reduce_480(val, _values, result); end
1283
+ def _reduce_481(val, _values, result); end
1284
+ def _reduce_482(val, _values, result); end
1285
+ def _reduce_483(val, _values, result); end
1286
+ def _reduce_484(val, _values, result); end
1287
+ def _reduce_486(val, _values, result); end
1288
+ def _reduce_487(val, _values, result); end
1289
+ def _reduce_488(val, _values, result); end
1290
+ def _reduce_489(val, _values, result); end
1291
+ def _reduce_49(val, _values, result); end
1292
+ def _reduce_490(val, _values, result); end
1293
+ def _reduce_491(val, _values, result); end
1294
+ def _reduce_492(val, _values, result); end
1295
+ def _reduce_493(val, _values, result); end
1296
+ def _reduce_494(val, _values, result); end
1297
+ def _reduce_495(val, _values, result); end
1298
+ def _reduce_496(val, _values, result); end
1299
+ def _reduce_497(val, _values, result); end
1300
+ def _reduce_498(val, _values, result); end
1301
+ def _reduce_499(val, _values, result); end
1302
+ def _reduce_5(val, _values, result); end
1303
+ def _reduce_50(val, _values, result); end
1304
+ def _reduce_500(val, _values, result); end
1305
+ def _reduce_502(val, _values, result); end
1306
+ def _reduce_503(val, _values, result); end
1307
+ def _reduce_504(val, _values, result); end
1308
+ def _reduce_505(val, _values, result); end
1309
+ def _reduce_509(val, _values, result); end
1310
+ def _reduce_51(val, _values, result); end
1311
+ def _reduce_510(val, _values, result); end
1312
+ def _reduce_519(val, _values, result); end
1313
+ def _reduce_52(val, _values, result); end
1314
+ def _reduce_520(val, _values, result); end
1315
+ def _reduce_521(val, _values, result); end
1316
+ def _reduce_522(val, _values, result); end
1317
+ def _reduce_523(val, _values, result); end
1318
+ def _reduce_524(val, _values, result); end
1319
+ def _reduce_525(val, _values, result); end
1320
+ def _reduce_526(val, _values, result); end
1321
+ def _reduce_527(val, _values, result); end
1322
+ def _reduce_528(val, _values, result); end
1323
+ def _reduce_529(val, _values, result); end
1324
+ def _reduce_53(val, _values, result); end
1325
+ def _reduce_532(val, _values, result); end
1326
+ def _reduce_534(val, _values, result); end
1327
+ def _reduce_538(val, _values, result); end
1328
+ def _reduce_539(val, _values, result); end
1329
+ def _reduce_54(val, _values, result); end
1330
+ def _reduce_540(val, _values, result); end
1331
+ def _reduce_541(val, _values, result); end
1332
+ def _reduce_542(val, _values, result); end
1333
+ def _reduce_543(val, _values, result); end
1334
+ def _reduce_544(val, _values, result); end
1335
+ def _reduce_545(val, _values, result); end
1336
+ def _reduce_546(val, _values, result); end
1337
+ def _reduce_547(val, _values, result); end
1338
+ def _reduce_548(val, _values, result); end
1339
+ def _reduce_549(val, _values, result); end
1340
+ def _reduce_550(val, _values, result); end
1341
+ def _reduce_551(val, _values, result); end
1342
+ def _reduce_552(val, _values, result); end
1343
+ def _reduce_553(val, _values, result); end
1344
+ def _reduce_554(val, _values, result); end
1345
+ def _reduce_555(val, _values, result); end
1346
+ def _reduce_556(val, _values, result); end
1347
+ def _reduce_557(val, _values, result); end
1348
+ def _reduce_558(val, _values, result); end
1349
+ def _reduce_559(val, _values, result); end
1350
+ def _reduce_560(val, _values, result); end
1351
+ def _reduce_561(val, _values, result); end
1352
+ def _reduce_562(val, _values, result); end
1353
+ def _reduce_563(val, _values, result); end
1354
+ def _reduce_564(val, _values, result); end
1355
+ def _reduce_565(val, _values, result); end
1356
+ def _reduce_566(val, _values, result); end
1357
+ def _reduce_567(val, _values, result); end
1358
+ def _reduce_568(val, _values, result); end
1359
+ def _reduce_569(val, _values, result); end
1360
+ def _reduce_57(val, _values, result); end
1361
+ def _reduce_570(val, _values, result); end
1362
+ def _reduce_571(val, _values, result); end
1363
+ def _reduce_572(val, _values, result); end
1364
+ def _reduce_576(val, _values, result); end
1365
+ def _reduce_577(val, _values, result); end
1366
+ def _reduce_578(val, _values, result); end
1367
+ def _reduce_579(val, _values, result); end
1368
+ def _reduce_58(val, _values, result); end
1369
+ def _reduce_580(val, _values, result); end
1370
+ def _reduce_581(val, _values, result); end
1371
+ def _reduce_582(val, _values, result); end
1372
+ def _reduce_583(val, _values, result); end
1373
+ def _reduce_584(val, _values, result); end
1374
+ def _reduce_585(val, _values, result); end
1375
+ def _reduce_586(val, _values, result); end
1376
+ def _reduce_587(val, _values, result); end
1377
+ def _reduce_588(val, _values, result); end
1378
+ def _reduce_589(val, _values, result); end
1379
+ def _reduce_590(val, _values, result); end
1380
+ def _reduce_591(val, _values, result); end
1381
+ def _reduce_592(val, _values, result); end
1382
+ def _reduce_593(val, _values, result); end
1383
+ def _reduce_594(val, _values, result); end
1384
+ def _reduce_595(val, _values, result); end
1385
+ def _reduce_596(val, _values, result); end
1386
+ def _reduce_597(val, _values, result); end
1387
+ def _reduce_598(val, _values, result); end
1388
+ def _reduce_599(val, _values, result); end
1389
+ def _reduce_6(val, _values, result); end
1390
+ def _reduce_600(val, _values, result); end
1391
+ def _reduce_601(val, _values, result); end
1392
+ def _reduce_602(val, _values, result); end
1393
+ def _reduce_603(val, _values, result); end
1394
+ def _reduce_604(val, _values, result); end
1395
+ def _reduce_605(val, _values, result); end
1396
+ def _reduce_606(val, _values, result); end
1397
+ def _reduce_607(val, _values, result); end
1398
+ def _reduce_608(val, _values, result); end
1399
+ def _reduce_609(val, _values, result); end
1400
+ def _reduce_610(val, _values, result); end
1401
+ def _reduce_611(val, _values, result); end
1402
+ def _reduce_612(val, _values, result); end
1403
+ def _reduce_613(val, _values, result); end
1404
+ def _reduce_614(val, _values, result); end
1405
+ def _reduce_615(val, _values, result); end
1406
+ def _reduce_616(val, _values, result); end
1407
+ def _reduce_617(val, _values, result); end
1408
+ def _reduce_618(val, _values, result); end
1409
+ def _reduce_619(val, _values, result); end
1410
+ def _reduce_62(val, _values, result); end
1411
+ def _reduce_620(val, _values, result); end
1412
+ def _reduce_621(val, _values, result); end
1413
+ def _reduce_622(val, _values, result); end
1414
+ def _reduce_623(val, _values, result); end
1415
+ def _reduce_624(val, _values, result); end
1416
+ def _reduce_625(val, _values, result); end
1417
+ def _reduce_626(val, _values, result); end
1418
+ def _reduce_627(val, _values, result); end
1419
+ def _reduce_628(val, _values, result); end
1420
+ def _reduce_629(val, _values, result); end
1421
+ def _reduce_63(val, _values, result); end
1422
+ def _reduce_630(val, _values, result); end
1423
+ def _reduce_631(val, _values, result); end
1424
+ def _reduce_632(val, _values, result); end
1425
+ def _reduce_633(val, _values, result); end
1426
+ def _reduce_634(val, _values, result); end
1427
+ def _reduce_635(val, _values, result); end
1428
+ def _reduce_637(val, _values, result); end
1429
+ def _reduce_638(val, _values, result); end
1430
+ def _reduce_639(val, _values, result); end
1431
+ def _reduce_64(val, _values, result); end
1432
+ def _reduce_640(val, _values, result); end
1433
+ def _reduce_641(val, _values, result); end
1434
+ def _reduce_642(val, _values, result); end
1435
+ def _reduce_643(val, _values, result); end
1436
+ def _reduce_644(val, _values, result); end
1437
+ def _reduce_645(val, _values, result); end
1438
+ def _reduce_646(val, _values, result); end
1439
+ def _reduce_647(val, _values, result); end
1440
+ def _reduce_648(val, _values, result); end
1441
+ def _reduce_649(val, _values, result); end
1442
+ def _reduce_650(val, _values, result); end
1443
+ def _reduce_651(val, _values, result); end
1444
+ def _reduce_654(val, _values, result); end
1445
+ def _reduce_655(val, _values, result); end
1446
+ def _reduce_656(val, _values, result); end
1447
+ def _reduce_657(val, _values, result); end
1448
+ def _reduce_658(val, _values, result); end
1449
+ def _reduce_659(val, _values, result); end
1450
+ def _reduce_66(val, _values, result); end
1451
+ def _reduce_660(val, _values, result); end
1452
+ def _reduce_661(val, _values, result); end
1453
+ def _reduce_662(val, _values, result); end
1454
+ def _reduce_665(val, _values, result); end
1455
+ def _reduce_666(val, _values, result); end
1456
+ def _reduce_669(val, _values, result); end
1457
+ def _reduce_67(val, _values, result); end
1458
+ def _reduce_670(val, _values, result); end
1459
+ def _reduce_671(val, _values, result); end
1460
+ def _reduce_673(val, _values, result); end
1461
+ def _reduce_674(val, _values, result); end
1462
+ def _reduce_676(val, _values, result); end
1463
+ def _reduce_677(val, _values, result); end
1464
+ def _reduce_678(val, _values, result); end
1465
+ def _reduce_679(val, _values, result); end
1466
+ def _reduce_68(val, _values, result); end
1467
+ def _reduce_680(val, _values, result); end
1468
+ def _reduce_681(val, _values, result); end
1469
+ def _reduce_69(val, _values, result); end
1470
+ def _reduce_694(val, _values, result); end
1471
+ def _reduce_695(val, _values, result); end
1472
+ def _reduce_7(val, _values, result); end
1473
+ def _reduce_70(val, _values, result); end
1474
+ def _reduce_700(val, _values, result); end
1475
+ def _reduce_701(val, _values, result); end
1476
+ def _reduce_702(val, _values, result); end
1477
+ def _reduce_706(val, _values, result); end
1478
+ def _reduce_71(val, _values, result); end
1479
+ def _reduce_710(val, _values, result); end
1480
+ def _reduce_72(val, _values, result); end
1481
+ def _reduce_73(val, _values, result); end
1482
+ def _reduce_74(val, _values, result); end
1483
+ def _reduce_75(val, _values, result); end
1484
+ def _reduce_76(val, _values, result); end
1485
+ def _reduce_77(val, _values, result); end
1486
+ def _reduce_78(val, _values, result); end
1487
+ def _reduce_79(val, _values, result); end
1488
+ def _reduce_80(val, _values, result); end
1489
+ def _reduce_82(val, _values, result); end
1490
+ def _reduce_83(val, _values, result); end
1491
+ def _reduce_84(val, _values, result); end
1492
+ def _reduce_85(val, _values, result); end
1493
+ def _reduce_86(val, _values, result); end
1494
+ def _reduce_87(val, _values, result); end
1495
+ def _reduce_88(val, _values, result); end
1496
+ def _reduce_89(val, _values, result); end
1497
+ def _reduce_9(val, _values, result); end
1498
+ def _reduce_90(val, _values, result); end
1499
+ def _reduce_92(val, _values, result); end
1500
+ def _reduce_93(val, _values, result); end
1501
+ def _reduce_94(val, _values, result); end
1502
+ def _reduce_95(val, _values, result); end
1503
+ def _reduce_96(val, _values, result); end
1504
+ def _reduce_97(val, _values, result); end
1505
+ def _reduce_98(val, _values, result); end
1506
+ def _reduce_99(val, _values, result); end
1507
+ def _reduce_none(val, _values, result); end
1508
+ def default_encoding; end
1509
+ def version; end
1510
+ end