yarp 0.10.0 → 0.12.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.
data/src/serialize.c CHANGED
@@ -65,27 +65,33 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
65
65
  switch (YP_NODE_TYPE(node)) {
66
66
  // We do not need to serialize a ScopeNode ever as
67
67
  // it is not part of the AST
68
- case YP_NODE_SCOPE_NODE:
68
+ case YP_SCOPE_NODE:
69
69
  return;
70
- case YP_NODE_ALIAS_NODE: {
71
- yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->new_name, buffer);
72
- yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->old_name, buffer);
73
- yp_serialize_location(parser, &((yp_alias_node_t *)node)->keyword_loc, buffer);
70
+ case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
71
+ yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->new_name, buffer);
72
+ yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->old_name, buffer);
73
+ yp_serialize_location(parser, &((yp_alias_global_variable_node_t *)node)->keyword_loc, buffer);
74
74
  break;
75
75
  }
76
- case YP_NODE_ALTERNATION_PATTERN_NODE: {
76
+ case YP_ALIAS_METHOD_NODE: {
77
+ yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->new_name, buffer);
78
+ yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->old_name, buffer);
79
+ yp_serialize_location(parser, &((yp_alias_method_node_t *)node)->keyword_loc, buffer);
80
+ break;
81
+ }
82
+ case YP_ALTERNATION_PATTERN_NODE: {
77
83
  yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->left, buffer);
78
84
  yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->right, buffer);
79
85
  yp_serialize_location(parser, &((yp_alternation_pattern_node_t *)node)->operator_loc, buffer);
80
86
  break;
81
87
  }
82
- case YP_NODE_AND_NODE: {
88
+ case YP_AND_NODE: {
83
89
  yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->left, buffer);
84
90
  yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->right, buffer);
85
91
  yp_serialize_location(parser, &((yp_and_node_t *)node)->operator_loc, buffer);
86
92
  break;
87
93
  }
88
- case YP_NODE_ARGUMENTS_NODE: {
94
+ case YP_ARGUMENTS_NODE: {
89
95
  uint32_t arguments_size = yp_sizet_to_u32(((yp_arguments_node_t *)node)->arguments.size);
90
96
  yp_buffer_append_u32(buffer, arguments_size);
91
97
  for (uint32_t index = 0; index < arguments_size; index++) {
@@ -93,7 +99,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
93
99
  }
94
100
  break;
95
101
  }
96
- case YP_NODE_ARRAY_NODE: {
102
+ case YP_ARRAY_NODE: {
97
103
  uint32_t elements_size = yp_sizet_to_u32(((yp_array_node_t *)node)->elements.size);
98
104
  yp_buffer_append_u32(buffer, elements_size);
99
105
  for (uint32_t index = 0; index < elements_size; index++) {
@@ -113,7 +119,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
113
119
  }
114
120
  break;
115
121
  }
116
- case YP_NODE_ARRAY_PATTERN_NODE: {
122
+ case YP_ARRAY_PATTERN_NODE: {
117
123
  if (((yp_array_pattern_node_t *)node)->constant == NULL) {
118
124
  yp_buffer_append_u8(buffer, 0);
119
125
  } else {
@@ -148,7 +154,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
148
154
  }
149
155
  break;
150
156
  }
151
- case YP_NODE_ASSOC_NODE: {
157
+ case YP_ASSOC_NODE: {
152
158
  yp_serialize_node(parser, (yp_node_t *)((yp_assoc_node_t *)node)->key, buffer);
153
159
  if (((yp_assoc_node_t *)node)->value == NULL) {
154
160
  yp_buffer_append_u8(buffer, 0);
@@ -163,7 +169,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
163
169
  }
164
170
  break;
165
171
  }
166
- case YP_NODE_ASSOC_SPLAT_NODE: {
172
+ case YP_ASSOC_SPLAT_NODE: {
167
173
  if (((yp_assoc_splat_node_t *)node)->value == NULL) {
168
174
  yp_buffer_append_u8(buffer, 0);
169
175
  } else {
@@ -172,10 +178,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
172
178
  yp_serialize_location(parser, &((yp_assoc_splat_node_t *)node)->operator_loc, buffer);
173
179
  break;
174
180
  }
175
- case YP_NODE_BACK_REFERENCE_READ_NODE: {
181
+ case YP_BACK_REFERENCE_READ_NODE: {
176
182
  break;
177
183
  }
178
- case YP_NODE_BEGIN_NODE: {
184
+ case YP_BEGIN_NODE: {
179
185
  if (((yp_begin_node_t *)node)->begin_keyword_loc.start == NULL) {
180
186
  yp_buffer_append_u8(buffer, 0);
181
187
  } else {
@@ -210,7 +216,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
210
216
  }
211
217
  break;
212
218
  }
213
- case YP_NODE_BLOCK_ARGUMENT_NODE: {
219
+ case YP_BLOCK_ARGUMENT_NODE: {
214
220
  if (((yp_block_argument_node_t *)node)->expression == NULL) {
215
221
  yp_buffer_append_u8(buffer, 0);
216
222
  } else {
@@ -219,7 +225,11 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
219
225
  yp_serialize_location(parser, &((yp_block_argument_node_t *)node)->operator_loc, buffer);
220
226
  break;
221
227
  }
222
- case YP_NODE_BLOCK_NODE: {
228
+ case YP_BLOCK_LOCAL_VARIABLE_NODE: {
229
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_block_local_variable_node_t *)node)->name));
230
+ break;
231
+ }
232
+ case YP_BLOCK_NODE: {
223
233
  uint32_t locals_size = yp_sizet_to_u32(((yp_block_node_t *)node)->locals.size);
224
234
  yp_buffer_append_u32(buffer, locals_size);
225
235
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -239,7 +249,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
239
249
  yp_serialize_location(parser, &((yp_block_node_t *)node)->closing_loc, buffer);
240
250
  break;
241
251
  }
242
- case YP_NODE_BLOCK_PARAMETER_NODE: {
252
+ case YP_BLOCK_PARAMETER_NODE: {
253
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_block_parameter_node_t *)node)->name));
243
254
  if (((yp_block_parameter_node_t *)node)->name_loc.start == NULL) {
244
255
  yp_buffer_append_u8(buffer, 0);
245
256
  } else {
@@ -249,7 +260,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
249
260
  yp_serialize_location(parser, &((yp_block_parameter_node_t *)node)->operator_loc, buffer);
250
261
  break;
251
262
  }
252
- case YP_NODE_BLOCK_PARAMETERS_NODE: {
263
+ case YP_BLOCK_PARAMETERS_NODE: {
253
264
  if (((yp_block_parameters_node_t *)node)->parameters == NULL) {
254
265
  yp_buffer_append_u8(buffer, 0);
255
266
  } else {
@@ -258,7 +269,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
258
269
  uint32_t locals_size = yp_sizet_to_u32(((yp_block_parameters_node_t *)node)->locals.size);
259
270
  yp_buffer_append_u32(buffer, locals_size);
260
271
  for (uint32_t index = 0; index < locals_size; index++) {
261
- yp_serialize_location(parser, &((yp_block_parameters_node_t *)node)->locals.locations[index], buffer);
272
+ yp_serialize_node(parser, (yp_node_t *) ((yp_block_parameters_node_t *)node)->locals.nodes[index], buffer);
262
273
  }
263
274
  if (((yp_block_parameters_node_t *)node)->opening_loc.start == NULL) {
264
275
  yp_buffer_append_u8(buffer, 0);
@@ -274,7 +285,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
274
285
  }
275
286
  break;
276
287
  }
277
- case YP_NODE_BREAK_NODE: {
288
+ case YP_BREAK_NODE: {
278
289
  if (((yp_break_node_t *)node)->arguments == NULL) {
279
290
  yp_buffer_append_u8(buffer, 0);
280
291
  } else {
@@ -283,17 +294,59 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
283
294
  yp_serialize_location(parser, &((yp_break_node_t *)node)->keyword_loc, buffer);
284
295
  break;
285
296
  }
286
- case YP_NODE_CALL_NODE: {
297
+ case YP_CALL_AND_WRITE_NODE: {
298
+ if (((yp_call_and_write_node_t *)node)->receiver == NULL) {
299
+ yp_buffer_append_u8(buffer, 0);
300
+ } else {
301
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->receiver, buffer);
302
+ }
303
+ if (((yp_call_and_write_node_t *)node)->call_operator_loc.start == NULL) {
304
+ yp_buffer_append_u8(buffer, 0);
305
+ } else {
306
+ yp_buffer_append_u8(buffer, 1);
307
+ yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->call_operator_loc, buffer);
308
+ }
309
+ if (((yp_call_and_write_node_t *)node)->message_loc.start == NULL) {
310
+ yp_buffer_append_u8(buffer, 0);
311
+ } else {
312
+ yp_buffer_append_u8(buffer, 1);
313
+ yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->message_loc, buffer);
314
+ }
315
+ if (((yp_call_and_write_node_t *)node)->opening_loc.start == NULL) {
316
+ yp_buffer_append_u8(buffer, 0);
317
+ } else {
318
+ yp_buffer_append_u8(buffer, 1);
319
+ yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->opening_loc, buffer);
320
+ }
321
+ if (((yp_call_and_write_node_t *)node)->arguments == NULL) {
322
+ yp_buffer_append_u8(buffer, 0);
323
+ } else {
324
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->arguments, buffer);
325
+ }
326
+ if (((yp_call_and_write_node_t *)node)->closing_loc.start == NULL) {
327
+ yp_buffer_append_u8(buffer, 0);
328
+ } else {
329
+ yp_buffer_append_u8(buffer, 1);
330
+ yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->closing_loc, buffer);
331
+ }
332
+ yp_buffer_append_u32(buffer, node->flags >> 2);
333
+ yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->read_name, buffer);
334
+ yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->write_name, buffer);
335
+ yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->operator_loc, buffer);
336
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->value, buffer);
337
+ break;
338
+ }
339
+ case YP_CALL_NODE: {
287
340
  if (((yp_call_node_t *)node)->receiver == NULL) {
288
341
  yp_buffer_append_u8(buffer, 0);
289
342
  } else {
290
343
  yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->receiver, buffer);
291
344
  }
292
- if (((yp_call_node_t *)node)->operator_loc.start == NULL) {
345
+ if (((yp_call_node_t *)node)->call_operator_loc.start == NULL) {
293
346
  yp_buffer_append_u8(buffer, 0);
294
347
  } else {
295
348
  yp_buffer_append_u8(buffer, 1);
296
- yp_serialize_location(parser, &((yp_call_node_t *)node)->operator_loc, buffer);
349
+ yp_serialize_location(parser, &((yp_call_node_t *)node)->call_operator_loc, buffer);
297
350
  }
298
351
  if (((yp_call_node_t *)node)->message_loc.start == NULL) {
299
352
  yp_buffer_append_u8(buffer, 0);
@@ -323,36 +376,102 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
323
376
  } else {
324
377
  yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->block, buffer);
325
378
  }
326
- yp_buffer_append_u32(buffer, node->flags >> 1);
379
+ yp_buffer_append_u32(buffer, node->flags >> 2);
327
380
  yp_serialize_string(parser, &((yp_call_node_t *)node)->name, buffer);
328
381
  break;
329
382
  }
330
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
331
- yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->target, buffer);
332
- yp_serialize_location(parser, &((yp_call_operator_and_write_node_t *)node)->operator_loc, buffer);
333
- yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->value, buffer);
334
- break;
335
- }
336
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
337
- yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->target, buffer);
338
- yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->value, buffer);
339
- yp_serialize_location(parser, &((yp_call_operator_or_write_node_t *)node)->operator_loc, buffer);
340
- break;
341
- }
342
- case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
343
- yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->target, buffer);
383
+ case YP_CALL_OPERATOR_WRITE_NODE: {
384
+ if (((yp_call_operator_write_node_t *)node)->receiver == NULL) {
385
+ yp_buffer_append_u8(buffer, 0);
386
+ } else {
387
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->receiver, buffer);
388
+ }
389
+ if (((yp_call_operator_write_node_t *)node)->call_operator_loc.start == NULL) {
390
+ yp_buffer_append_u8(buffer, 0);
391
+ } else {
392
+ yp_buffer_append_u8(buffer, 1);
393
+ yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->call_operator_loc, buffer);
394
+ }
395
+ if (((yp_call_operator_write_node_t *)node)->message_loc.start == NULL) {
396
+ yp_buffer_append_u8(buffer, 0);
397
+ } else {
398
+ yp_buffer_append_u8(buffer, 1);
399
+ yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->message_loc, buffer);
400
+ }
401
+ if (((yp_call_operator_write_node_t *)node)->opening_loc.start == NULL) {
402
+ yp_buffer_append_u8(buffer, 0);
403
+ } else {
404
+ yp_buffer_append_u8(buffer, 1);
405
+ yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->opening_loc, buffer);
406
+ }
407
+ if (((yp_call_operator_write_node_t *)node)->arguments == NULL) {
408
+ yp_buffer_append_u8(buffer, 0);
409
+ } else {
410
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->arguments, buffer);
411
+ }
412
+ if (((yp_call_operator_write_node_t *)node)->closing_loc.start == NULL) {
413
+ yp_buffer_append_u8(buffer, 0);
414
+ } else {
415
+ yp_buffer_append_u8(buffer, 1);
416
+ yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->closing_loc, buffer);
417
+ }
418
+ yp_buffer_append_u32(buffer, node->flags >> 2);
419
+ yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->read_name, buffer);
420
+ yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->write_name, buffer);
421
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
344
422
  yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->operator_loc, buffer);
345
423
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->value, buffer);
346
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
347
424
  break;
348
425
  }
349
- case YP_NODE_CAPTURE_PATTERN_NODE: {
426
+ case YP_CALL_OR_WRITE_NODE: {
427
+ if (((yp_call_or_write_node_t *)node)->receiver == NULL) {
428
+ yp_buffer_append_u8(buffer, 0);
429
+ } else {
430
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->receiver, buffer);
431
+ }
432
+ if (((yp_call_or_write_node_t *)node)->call_operator_loc.start == NULL) {
433
+ yp_buffer_append_u8(buffer, 0);
434
+ } else {
435
+ yp_buffer_append_u8(buffer, 1);
436
+ yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->call_operator_loc, buffer);
437
+ }
438
+ if (((yp_call_or_write_node_t *)node)->message_loc.start == NULL) {
439
+ yp_buffer_append_u8(buffer, 0);
440
+ } else {
441
+ yp_buffer_append_u8(buffer, 1);
442
+ yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->message_loc, buffer);
443
+ }
444
+ if (((yp_call_or_write_node_t *)node)->opening_loc.start == NULL) {
445
+ yp_buffer_append_u8(buffer, 0);
446
+ } else {
447
+ yp_buffer_append_u8(buffer, 1);
448
+ yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->opening_loc, buffer);
449
+ }
450
+ if (((yp_call_or_write_node_t *)node)->arguments == NULL) {
451
+ yp_buffer_append_u8(buffer, 0);
452
+ } else {
453
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->arguments, buffer);
454
+ }
455
+ if (((yp_call_or_write_node_t *)node)->closing_loc.start == NULL) {
456
+ yp_buffer_append_u8(buffer, 0);
457
+ } else {
458
+ yp_buffer_append_u8(buffer, 1);
459
+ yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->closing_loc, buffer);
460
+ }
461
+ yp_buffer_append_u32(buffer, node->flags >> 2);
462
+ yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->read_name, buffer);
463
+ yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->write_name, buffer);
464
+ yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->operator_loc, buffer);
465
+ yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->value, buffer);
466
+ break;
467
+ }
468
+ case YP_CAPTURE_PATTERN_NODE: {
350
469
  yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->value, buffer);
351
470
  yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->target, buffer);
352
471
  yp_serialize_location(parser, &((yp_capture_pattern_node_t *)node)->operator_loc, buffer);
353
472
  break;
354
473
  }
355
- case YP_NODE_CASE_NODE: {
474
+ case YP_CASE_NODE: {
356
475
  if (((yp_case_node_t *)node)->predicate == NULL) {
357
476
  yp_buffer_append_u8(buffer, 0);
358
477
  } else {
@@ -372,7 +491,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
372
491
  yp_serialize_location(parser, &((yp_case_node_t *)node)->end_keyword_loc, buffer);
373
492
  break;
374
493
  }
375
- case YP_NODE_CLASS_NODE: {
494
+ case YP_CLASS_NODE: {
376
495
  uint32_t locals_size = yp_sizet_to_u32(((yp_class_node_t *)node)->locals.size);
377
496
  yp_buffer_append_u32(buffer, locals_size);
378
497
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -397,17 +516,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
397
516
  yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->body, buffer);
398
517
  }
399
518
  yp_serialize_location(parser, &((yp_class_node_t *)node)->end_keyword_loc, buffer);
400
- yp_serialize_string(parser, &((yp_class_node_t *)node)->name, buffer);
519
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_node_t *)node)->name));
401
520
  break;
402
521
  }
403
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
522
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
404
523
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_and_write_node_t *)node)->name));
405
524
  yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->name_loc, buffer);
406
525
  yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->operator_loc, buffer);
407
526
  yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value, buffer);
408
527
  break;
409
528
  }
410
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
529
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
411
530
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->name));
412
531
  yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->name_loc, buffer);
413
532
  yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->operator_loc, buffer);
@@ -415,29 +534,25 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
415
534
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->operator));
416
535
  break;
417
536
  }
418
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
537
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
419
538
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_or_write_node_t *)node)->name));
420
539
  yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->name_loc, buffer);
421
540
  yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->operator_loc, buffer);
422
541
  yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value, buffer);
423
542
  break;
424
543
  }
425
- case YP_NODE_CLASS_VARIABLE_READ_NODE: {
544
+ case YP_CLASS_VARIABLE_READ_NODE: {
426
545
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_read_node_t *)node)->name));
427
546
  break;
428
547
  }
429
- case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
548
+ case YP_CLASS_VARIABLE_TARGET_NODE: {
430
549
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_target_node_t *)node)->name));
431
550
  break;
432
551
  }
433
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
552
+ case YP_CLASS_VARIABLE_WRITE_NODE: {
434
553
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_write_node_t *)node)->name));
435
554
  yp_serialize_location(parser, &((yp_class_variable_write_node_t *)node)->name_loc, buffer);
436
- if (((yp_class_variable_write_node_t *)node)->value == NULL) {
437
- yp_buffer_append_u8(buffer, 0);
438
- } else {
439
- yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value, buffer);
440
- }
555
+ yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value, buffer);
441
556
  if (((yp_class_variable_write_node_t *)node)->operator_loc.start == NULL) {
442
557
  yp_buffer_append_u8(buffer, 0);
443
558
  } else {
@@ -446,32 +561,35 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
446
561
  }
447
562
  break;
448
563
  }
449
- case YP_NODE_CONSTANT_AND_WRITE_NODE: {
564
+ case YP_CONSTANT_AND_WRITE_NODE: {
565
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_and_write_node_t *)node)->name));
450
566
  yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->name_loc, buffer);
451
567
  yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->operator_loc, buffer);
452
568
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_and_write_node_t *)node)->value, buffer);
453
569
  break;
454
570
  }
455
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
571
+ case YP_CONSTANT_OPERATOR_WRITE_NODE: {
572
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->name));
456
573
  yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->name_loc, buffer);
457
574
  yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->operator_loc, buffer);
458
575
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, buffer);
459
576
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->operator));
460
577
  break;
461
578
  }
462
- case YP_NODE_CONSTANT_OR_WRITE_NODE: {
579
+ case YP_CONSTANT_OR_WRITE_NODE: {
580
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_or_write_node_t *)node)->name));
463
581
  yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->name_loc, buffer);
464
582
  yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->operator_loc, buffer);
465
583
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_or_write_node_t *)node)->value, buffer);
466
584
  break;
467
585
  }
468
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
586
+ case YP_CONSTANT_PATH_AND_WRITE_NODE: {
469
587
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target, buffer);
470
588
  yp_serialize_location(parser, &((yp_constant_path_and_write_node_t *)node)->operator_loc, buffer);
471
589
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value, buffer);
472
590
  break;
473
591
  }
474
- case YP_NODE_CONSTANT_PATH_NODE: {
592
+ case YP_CONSTANT_PATH_NODE: {
475
593
  if (((yp_constant_path_node_t *)node)->parent == NULL) {
476
594
  yp_buffer_append_u8(buffer, 0);
477
595
  } else {
@@ -481,20 +599,20 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
481
599
  yp_serialize_location(parser, &((yp_constant_path_node_t *)node)->delimiter_loc, buffer);
482
600
  break;
483
601
  }
484
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
602
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
485
603
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, buffer);
486
604
  yp_serialize_location(parser, &((yp_constant_path_operator_write_node_t *)node)->operator_loc, buffer);
487
605
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, buffer);
488
606
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_path_operator_write_node_t *)node)->operator));
489
607
  break;
490
608
  }
491
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
609
+ case YP_CONSTANT_PATH_OR_WRITE_NODE: {
492
610
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target, buffer);
493
611
  yp_serialize_location(parser, &((yp_constant_path_or_write_node_t *)node)->operator_loc, buffer);
494
612
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value, buffer);
495
613
  break;
496
614
  }
497
- case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
615
+ case YP_CONSTANT_PATH_TARGET_NODE: {
498
616
  if (((yp_constant_path_target_node_t *)node)->parent == NULL) {
499
617
  yp_buffer_append_u8(buffer, 0);
500
618
  } else {
@@ -504,29 +622,33 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
504
622
  yp_serialize_location(parser, &((yp_constant_path_target_node_t *)node)->delimiter_loc, buffer);
505
623
  break;
506
624
  }
507
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
625
+ case YP_CONSTANT_PATH_WRITE_NODE: {
508
626
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target, buffer);
509
627
  yp_serialize_location(parser, &((yp_constant_path_write_node_t *)node)->operator_loc, buffer);
510
628
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value, buffer);
511
629
  break;
512
630
  }
513
- case YP_NODE_CONSTANT_READ_NODE: {
631
+ case YP_CONSTANT_READ_NODE: {
632
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_read_node_t *)node)->name));
514
633
  break;
515
634
  }
516
- case YP_NODE_CONSTANT_TARGET_NODE: {
635
+ case YP_CONSTANT_TARGET_NODE: {
636
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_target_node_t *)node)->name));
517
637
  break;
518
638
  }
519
- case YP_NODE_CONSTANT_WRITE_NODE: {
639
+ case YP_CONSTANT_WRITE_NODE: {
640
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_write_node_t *)node)->name));
520
641
  yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->name_loc, buffer);
521
642
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value, buffer);
522
643
  yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->operator_loc, buffer);
523
644
  break;
524
645
  }
525
- case YP_NODE_DEF_NODE: {
646
+ case YP_DEF_NODE: {
526
647
  // serialize length
527
648
  // encoding of location u32s make us need to save this offset.
528
649
  size_t length_offset = buffer->length;
529
650
  yp_buffer_append_str(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
651
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_def_node_t *)node)->name));
530
652
  yp_serialize_location(parser, &((yp_def_node_t *)node)->name_loc, buffer);
531
653
  if (((yp_def_node_t *)node)->receiver == NULL) {
532
654
  yp_buffer_append_u8(buffer, 0);
@@ -584,7 +706,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
584
706
  memcpy(buffer->value + length_offset, &length, sizeof(uint32_t));
585
707
  break;
586
708
  }
587
- case YP_NODE_DEFINED_NODE: {
709
+ case YP_DEFINED_NODE: {
588
710
  if (((yp_defined_node_t *)node)->lparen_loc.start == NULL) {
589
711
  yp_buffer_append_u8(buffer, 0);
590
712
  } else {
@@ -601,7 +723,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
601
723
  yp_serialize_location(parser, &((yp_defined_node_t *)node)->keyword_loc, buffer);
602
724
  break;
603
725
  }
604
- case YP_NODE_ELSE_NODE: {
726
+ case YP_ELSE_NODE: {
605
727
  yp_serialize_location(parser, &((yp_else_node_t *)node)->else_keyword_loc, buffer);
606
728
  if (((yp_else_node_t *)node)->statements == NULL) {
607
729
  yp_buffer_append_u8(buffer, 0);
@@ -616,7 +738,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
616
738
  }
617
739
  break;
618
740
  }
619
- case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
741
+ case YP_EMBEDDED_STATEMENTS_NODE: {
620
742
  yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->opening_loc, buffer);
621
743
  if (((yp_embedded_statements_node_t *)node)->statements == NULL) {
622
744
  yp_buffer_append_u8(buffer, 0);
@@ -626,12 +748,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
626
748
  yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->closing_loc, buffer);
627
749
  break;
628
750
  }
629
- case YP_NODE_EMBEDDED_VARIABLE_NODE: {
751
+ case YP_EMBEDDED_VARIABLE_NODE: {
630
752
  yp_serialize_location(parser, &((yp_embedded_variable_node_t *)node)->operator_loc, buffer);
631
753
  yp_serialize_node(parser, (yp_node_t *)((yp_embedded_variable_node_t *)node)->variable, buffer);
632
754
  break;
633
755
  }
634
- case YP_NODE_ENSURE_NODE: {
756
+ case YP_ENSURE_NODE: {
635
757
  yp_serialize_location(parser, &((yp_ensure_node_t *)node)->ensure_keyword_loc, buffer);
636
758
  if (((yp_ensure_node_t *)node)->statements == NULL) {
637
759
  yp_buffer_append_u8(buffer, 0);
@@ -641,10 +763,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
641
763
  yp_serialize_location(parser, &((yp_ensure_node_t *)node)->end_keyword_loc, buffer);
642
764
  break;
643
765
  }
644
- case YP_NODE_FALSE_NODE: {
766
+ case YP_FALSE_NODE: {
645
767
  break;
646
768
  }
647
- case YP_NODE_FIND_PATTERN_NODE: {
769
+ case YP_FIND_PATTERN_NODE: {
648
770
  if (((yp_find_pattern_node_t *)node)->constant == NULL) {
649
771
  yp_buffer_append_u8(buffer, 0);
650
772
  } else {
@@ -671,7 +793,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
671
793
  }
672
794
  break;
673
795
  }
674
- case YP_NODE_FLIP_FLOP_NODE: {
796
+ case YP_FLIP_FLOP_NODE: {
675
797
  if (((yp_flip_flop_node_t *)node)->left == NULL) {
676
798
  yp_buffer_append_u8(buffer, 0);
677
799
  } else {
@@ -683,13 +805,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
683
805
  yp_serialize_node(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->right, buffer);
684
806
  }
685
807
  yp_serialize_location(parser, &((yp_flip_flop_node_t *)node)->operator_loc, buffer);
686
- yp_buffer_append_u32(buffer, node->flags >> 1);
808
+ yp_buffer_append_u32(buffer, node->flags >> 2);
687
809
  break;
688
810
  }
689
- case YP_NODE_FLOAT_NODE: {
811
+ case YP_FLOAT_NODE: {
690
812
  break;
691
813
  }
692
- case YP_NODE_FOR_NODE: {
814
+ case YP_FOR_NODE: {
693
815
  yp_serialize_node(parser, (yp_node_t *)((yp_for_node_t *)node)->index, buffer);
694
816
  yp_serialize_node(parser, (yp_node_t *)((yp_for_node_t *)node)->collection, buffer);
695
817
  if (((yp_for_node_t *)node)->statements == NULL) {
@@ -708,13 +830,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
708
830
  yp_serialize_location(parser, &((yp_for_node_t *)node)->end_keyword_loc, buffer);
709
831
  break;
710
832
  }
711
- case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
833
+ case YP_FORWARDING_ARGUMENTS_NODE: {
712
834
  break;
713
835
  }
714
- case YP_NODE_FORWARDING_PARAMETER_NODE: {
836
+ case YP_FORWARDING_PARAMETER_NODE: {
715
837
  break;
716
838
  }
717
- case YP_NODE_FORWARDING_SUPER_NODE: {
839
+ case YP_FORWARDING_SUPER_NODE: {
718
840
  if (((yp_forwarding_super_node_t *)node)->block == NULL) {
719
841
  yp_buffer_append_u8(buffer, 0);
720
842
  } else {
@@ -722,38 +844,44 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
722
844
  }
723
845
  break;
724
846
  }
725
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
847
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
848
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_and_write_node_t *)node)->name));
726
849
  yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->name_loc, buffer);
727
850
  yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->operator_loc, buffer);
728
851
  yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value, buffer);
729
852
  break;
730
853
  }
731
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
854
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
855
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->name));
732
856
  yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->name_loc, buffer);
733
857
  yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->operator_loc, buffer);
734
858
  yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, buffer);
735
859
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->operator));
736
860
  break;
737
861
  }
738
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
862
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
863
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_or_write_node_t *)node)->name));
739
864
  yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->name_loc, buffer);
740
865
  yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->operator_loc, buffer);
741
866
  yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value, buffer);
742
867
  break;
743
868
  }
744
- case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
869
+ case YP_GLOBAL_VARIABLE_READ_NODE: {
870
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_read_node_t *)node)->name));
745
871
  break;
746
872
  }
747
- case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
873
+ case YP_GLOBAL_VARIABLE_TARGET_NODE: {
874
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_target_node_t *)node)->name));
748
875
  break;
749
876
  }
750
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
877
+ case YP_GLOBAL_VARIABLE_WRITE_NODE: {
878
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_write_node_t *)node)->name));
751
879
  yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->name_loc, buffer);
752
880
  yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value, buffer);
753
881
  yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->operator_loc, buffer);
754
882
  break;
755
883
  }
756
- case YP_NODE_HASH_NODE: {
884
+ case YP_HASH_NODE: {
757
885
  yp_serialize_location(parser, &((yp_hash_node_t *)node)->opening_loc, buffer);
758
886
  uint32_t elements_size = yp_sizet_to_u32(((yp_hash_node_t *)node)->elements.size);
759
887
  yp_buffer_append_u32(buffer, elements_size);
@@ -763,7 +891,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
763
891
  yp_serialize_location(parser, &((yp_hash_node_t *)node)->closing_loc, buffer);
764
892
  break;
765
893
  }
766
- case YP_NODE_HASH_PATTERN_NODE: {
894
+ case YP_HASH_PATTERN_NODE: {
767
895
  if (((yp_hash_pattern_node_t *)node)->constant == NULL) {
768
896
  yp_buffer_append_u8(buffer, 0);
769
897
  } else {
@@ -793,7 +921,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
793
921
  }
794
922
  break;
795
923
  }
796
- case YP_NODE_IF_NODE: {
924
+ case YP_IF_NODE: {
797
925
  if (((yp_if_node_t *)node)->if_keyword_loc.start == NULL) {
798
926
  yp_buffer_append_u8(buffer, 0);
799
927
  } else {
@@ -819,11 +947,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
819
947
  }
820
948
  break;
821
949
  }
822
- case YP_NODE_IMAGINARY_NODE: {
950
+ case YP_IMAGINARY_NODE: {
823
951
  yp_serialize_node(parser, (yp_node_t *)((yp_imaginary_node_t *)node)->numeric, buffer);
824
952
  break;
825
953
  }
826
- case YP_NODE_IN_NODE: {
954
+ case YP_IMPLICIT_NODE: {
955
+ yp_serialize_node(parser, (yp_node_t *)((yp_implicit_node_t *)node)->value, buffer);
956
+ break;
957
+ }
958
+ case YP_IN_NODE: {
827
959
  yp_serialize_node(parser, (yp_node_t *)((yp_in_node_t *)node)->pattern, buffer);
828
960
  if (((yp_in_node_t *)node)->statements == NULL) {
829
961
  yp_buffer_append_u8(buffer, 0);
@@ -839,14 +971,14 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
839
971
  }
840
972
  break;
841
973
  }
842
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
974
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
843
975
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_and_write_node_t *)node)->name));
844
976
  yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->name_loc, buffer);
845
977
  yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
846
978
  yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value, buffer);
847
979
  break;
848
980
  }
849
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
981
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
850
982
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->name));
851
983
  yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
852
984
  yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->operator_loc, buffer);
@@ -854,32 +986,44 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
854
986
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->operator));
855
987
  break;
856
988
  }
857
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
989
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
858
990
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_or_write_node_t *)node)->name));
859
991
  yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->name_loc, buffer);
860
992
  yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
861
993
  yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value, buffer);
862
994
  break;
863
995
  }
864
- case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
996
+ case YP_INSTANCE_VARIABLE_READ_NODE: {
865
997
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_read_node_t *)node)->name));
866
998
  break;
867
999
  }
868
- case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
1000
+ case YP_INSTANCE_VARIABLE_TARGET_NODE: {
869
1001
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_target_node_t *)node)->name));
870
1002
  break;
871
1003
  }
872
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
1004
+ case YP_INSTANCE_VARIABLE_WRITE_NODE: {
873
1005
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_write_node_t *)node)->name));
874
1006
  yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->name_loc, buffer);
875
1007
  yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, buffer);
876
1008
  yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->operator_loc, buffer);
877
1009
  break;
878
1010
  }
879
- case YP_NODE_INTEGER_NODE: {
1011
+ case YP_INTEGER_NODE: {
1012
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1013
+ break;
1014
+ }
1015
+ case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1016
+ yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
1017
+ uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_match_last_line_node_t *)node)->parts.size);
1018
+ yp_buffer_append_u32(buffer, parts_size);
1019
+ for (uint32_t index = 0; index < parts_size; index++) {
1020
+ yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_match_last_line_node_t *)node)->parts.nodes[index], buffer);
1021
+ }
1022
+ yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
1023
+ yp_buffer_append_u32(buffer, node->flags >> 2);
880
1024
  break;
881
1025
  }
882
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1026
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
883
1027
  yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
884
1028
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_regular_expression_node_t *)node)->parts.size);
885
1029
  yp_buffer_append_u32(buffer, parts_size);
@@ -887,10 +1031,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
887
1031
  yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
888
1032
  }
889
1033
  yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
890
- yp_buffer_append_u32(buffer, node->flags >> 1);
1034
+ yp_buffer_append_u32(buffer, node->flags >> 2);
891
1035
  break;
892
1036
  }
893
- case YP_NODE_INTERPOLATED_STRING_NODE: {
1037
+ case YP_INTERPOLATED_STRING_NODE: {
894
1038
  if (((yp_interpolated_string_node_t *)node)->opening_loc.start == NULL) {
895
1039
  yp_buffer_append_u8(buffer, 0);
896
1040
  } else {
@@ -910,7 +1054,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
910
1054
  }
911
1055
  break;
912
1056
  }
913
- case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
1057
+ case YP_INTERPOLATED_SYMBOL_NODE: {
914
1058
  if (((yp_interpolated_symbol_node_t *)node)->opening_loc.start == NULL) {
915
1059
  yp_buffer_append_u8(buffer, 0);
916
1060
  } else {
@@ -930,7 +1074,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
930
1074
  }
931
1075
  break;
932
1076
  }
933
- case YP_NODE_INTERPOLATED_X_STRING_NODE: {
1077
+ case YP_INTERPOLATED_X_STRING_NODE: {
934
1078
  yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->opening_loc, buffer);
935
1079
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_x_string_node_t *)node)->parts.size);
936
1080
  yp_buffer_append_u32(buffer, parts_size);
@@ -940,7 +1084,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
940
1084
  yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->closing_loc, buffer);
941
1085
  break;
942
1086
  }
943
- case YP_NODE_KEYWORD_HASH_NODE: {
1087
+ case YP_KEYWORD_HASH_NODE: {
944
1088
  uint32_t elements_size = yp_sizet_to_u32(((yp_keyword_hash_node_t *)node)->elements.size);
945
1089
  yp_buffer_append_u32(buffer, elements_size);
946
1090
  for (uint32_t index = 0; index < elements_size; index++) {
@@ -948,7 +1092,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
948
1092
  }
949
1093
  break;
950
1094
  }
951
- case YP_NODE_KEYWORD_PARAMETER_NODE: {
1095
+ case YP_KEYWORD_PARAMETER_NODE: {
1096
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_keyword_parameter_node_t *)node)->name));
952
1097
  yp_serialize_location(parser, &((yp_keyword_parameter_node_t *)node)->name_loc, buffer);
953
1098
  if (((yp_keyword_parameter_node_t *)node)->value == NULL) {
954
1099
  yp_buffer_append_u8(buffer, 0);
@@ -957,17 +1102,18 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
957
1102
  }
958
1103
  break;
959
1104
  }
960
- case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
961
- yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
1105
+ case YP_KEYWORD_REST_PARAMETER_NODE: {
1106
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_keyword_rest_parameter_node_t *)node)->name));
962
1107
  if (((yp_keyword_rest_parameter_node_t *)node)->name_loc.start == NULL) {
963
1108
  yp_buffer_append_u8(buffer, 0);
964
1109
  } else {
965
1110
  yp_buffer_append_u8(buffer, 1);
966
1111
  yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
967
1112
  }
1113
+ yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
968
1114
  break;
969
1115
  }
970
- case YP_NODE_LAMBDA_NODE: {
1116
+ case YP_LAMBDA_NODE: {
971
1117
  uint32_t locals_size = yp_sizet_to_u32(((yp_lambda_node_t *)node)->locals.size);
972
1118
  yp_buffer_append_u32(buffer, locals_size);
973
1119
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -988,7 +1134,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
988
1134
  }
989
1135
  break;
990
1136
  }
991
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
1137
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
992
1138
  yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->name_loc, buffer);
993
1139
  yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->operator_loc, buffer);
994
1140
  yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value, buffer);
@@ -996,7 +1142,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
996
1142
  yp_buffer_append_u32(buffer, ((yp_local_variable_and_write_node_t *)node)->depth);
997
1143
  break;
998
1144
  }
999
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1145
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1000
1146
  yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->name_loc, buffer);
1001
1147
  yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->operator_loc, buffer);
1002
1148
  yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, buffer);
@@ -1005,7 +1151,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1005
1151
  yp_buffer_append_u32(buffer, ((yp_local_variable_operator_write_node_t *)node)->depth);
1006
1152
  break;
1007
1153
  }
1008
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
1154
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
1009
1155
  yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->name_loc, buffer);
1010
1156
  yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->operator_loc, buffer);
1011
1157
  yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value, buffer);
@@ -1013,17 +1159,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1013
1159
  yp_buffer_append_u32(buffer, ((yp_local_variable_or_write_node_t *)node)->depth);
1014
1160
  break;
1015
1161
  }
1016
- case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
1162
+ case YP_LOCAL_VARIABLE_READ_NODE: {
1017
1163
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_read_node_t *)node)->name));
1018
1164
  yp_buffer_append_u32(buffer, ((yp_local_variable_read_node_t *)node)->depth);
1019
1165
  break;
1020
1166
  }
1021
- case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
1167
+ case YP_LOCAL_VARIABLE_TARGET_NODE: {
1022
1168
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_target_node_t *)node)->name));
1023
1169
  yp_buffer_append_u32(buffer, ((yp_local_variable_target_node_t *)node)->depth);
1024
1170
  break;
1025
1171
  }
1026
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
1172
+ case YP_LOCAL_VARIABLE_WRITE_NODE: {
1027
1173
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_write_node_t *)node)->name));
1028
1174
  yp_buffer_append_u32(buffer, ((yp_local_variable_write_node_t *)node)->depth);
1029
1175
  yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->name_loc, buffer);
@@ -1031,22 +1177,39 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1031
1177
  yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->operator_loc, buffer);
1032
1178
  break;
1033
1179
  }
1034
- case YP_NODE_MATCH_PREDICATE_NODE: {
1180
+ case YP_MATCH_LAST_LINE_NODE: {
1181
+ yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->opening_loc, buffer);
1182
+ yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->content_loc, buffer);
1183
+ yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->closing_loc, buffer);
1184
+ yp_serialize_string(parser, &((yp_match_last_line_node_t *)node)->unescaped, buffer);
1185
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1186
+ break;
1187
+ }
1188
+ case YP_MATCH_PREDICATE_NODE: {
1035
1189
  yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->value, buffer);
1036
1190
  yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, buffer);
1037
1191
  yp_serialize_location(parser, &((yp_match_predicate_node_t *)node)->operator_loc, buffer);
1038
1192
  break;
1039
1193
  }
1040
- case YP_NODE_MATCH_REQUIRED_NODE: {
1194
+ case YP_MATCH_REQUIRED_NODE: {
1041
1195
  yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->value, buffer);
1042
1196
  yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->pattern, buffer);
1043
1197
  yp_serialize_location(parser, &((yp_match_required_node_t *)node)->operator_loc, buffer);
1044
1198
  break;
1045
1199
  }
1046
- case YP_NODE_MISSING_NODE: {
1200
+ case YP_MATCH_WRITE_NODE: {
1201
+ yp_serialize_node(parser, (yp_node_t *)((yp_match_write_node_t *)node)->call, buffer);
1202
+ uint32_t locals_size = yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.size);
1203
+ yp_buffer_append_u32(buffer, locals_size);
1204
+ for (uint32_t index = 0; index < locals_size; index++) {
1205
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.ids[index]));
1206
+ }
1207
+ break;
1208
+ }
1209
+ case YP_MISSING_NODE: {
1047
1210
  break;
1048
1211
  }
1049
- case YP_NODE_MODULE_NODE: {
1212
+ case YP_MODULE_NODE: {
1050
1213
  uint32_t locals_size = yp_sizet_to_u32(((yp_module_node_t *)node)->locals.size);
1051
1214
  yp_buffer_append_u32(buffer, locals_size);
1052
1215
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -1060,25 +1223,34 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1060
1223
  yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->body, buffer);
1061
1224
  }
1062
1225
  yp_serialize_location(parser, &((yp_module_node_t *)node)->end_keyword_loc, buffer);
1063
- yp_serialize_string(parser, &((yp_module_node_t *)node)->name, buffer);
1226
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_module_node_t *)node)->name));
1064
1227
  break;
1065
1228
  }
1066
- case YP_NODE_MULTI_WRITE_NODE: {
1067
- uint32_t targets_size = yp_sizet_to_u32(((yp_multi_write_node_t *)node)->targets.size);
1229
+ case YP_MULTI_TARGET_NODE: {
1230
+ uint32_t targets_size = yp_sizet_to_u32(((yp_multi_target_node_t *)node)->targets.size);
1068
1231
  yp_buffer_append_u32(buffer, targets_size);
1069
1232
  for (uint32_t index = 0; index < targets_size; index++) {
1070
- yp_serialize_node(parser, (yp_node_t *) ((yp_multi_write_node_t *)node)->targets.nodes[index], buffer);
1233
+ yp_serialize_node(parser, (yp_node_t *) ((yp_multi_target_node_t *)node)->targets.nodes[index], buffer);
1071
1234
  }
1072
- if (((yp_multi_write_node_t *)node)->operator_loc.start == NULL) {
1235
+ if (((yp_multi_target_node_t *)node)->lparen_loc.start == NULL) {
1073
1236
  yp_buffer_append_u8(buffer, 0);
1074
1237
  } else {
1075
1238
  yp_buffer_append_u8(buffer, 1);
1076
- yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->operator_loc, buffer);
1239
+ yp_serialize_location(parser, &((yp_multi_target_node_t *)node)->lparen_loc, buffer);
1077
1240
  }
1078
- if (((yp_multi_write_node_t *)node)->value == NULL) {
1241
+ if (((yp_multi_target_node_t *)node)->rparen_loc.start == NULL) {
1079
1242
  yp_buffer_append_u8(buffer, 0);
1080
1243
  } else {
1081
- yp_serialize_node(parser, (yp_node_t *)((yp_multi_write_node_t *)node)->value, buffer);
1244
+ yp_buffer_append_u8(buffer, 1);
1245
+ yp_serialize_location(parser, &((yp_multi_target_node_t *)node)->rparen_loc, buffer);
1246
+ }
1247
+ break;
1248
+ }
1249
+ case YP_MULTI_WRITE_NODE: {
1250
+ uint32_t targets_size = yp_sizet_to_u32(((yp_multi_write_node_t *)node)->targets.size);
1251
+ yp_buffer_append_u32(buffer, targets_size);
1252
+ for (uint32_t index = 0; index < targets_size; index++) {
1253
+ yp_serialize_node(parser, (yp_node_t *) ((yp_multi_write_node_t *)node)->targets.nodes[index], buffer);
1082
1254
  }
1083
1255
  if (((yp_multi_write_node_t *)node)->lparen_loc.start == NULL) {
1084
1256
  yp_buffer_append_u8(buffer, 0);
@@ -1092,9 +1264,11 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1092
1264
  yp_buffer_append_u8(buffer, 1);
1093
1265
  yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->rparen_loc, buffer);
1094
1266
  }
1267
+ yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->operator_loc, buffer);
1268
+ yp_serialize_node(parser, (yp_node_t *)((yp_multi_write_node_t *)node)->value, buffer);
1095
1269
  break;
1096
1270
  }
1097
- case YP_NODE_NEXT_NODE: {
1271
+ case YP_NEXT_NODE: {
1098
1272
  if (((yp_next_node_t *)node)->arguments == NULL) {
1099
1273
  yp_buffer_append_u8(buffer, 0);
1100
1274
  } else {
@@ -1103,32 +1277,32 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1103
1277
  yp_serialize_location(parser, &((yp_next_node_t *)node)->keyword_loc, buffer);
1104
1278
  break;
1105
1279
  }
1106
- case YP_NODE_NIL_NODE: {
1280
+ case YP_NIL_NODE: {
1107
1281
  break;
1108
1282
  }
1109
- case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
1283
+ case YP_NO_KEYWORDS_PARAMETER_NODE: {
1110
1284
  yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
1111
1285
  yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
1112
1286
  break;
1113
1287
  }
1114
- case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
1288
+ case YP_NUMBERED_REFERENCE_READ_NODE: {
1115
1289
  yp_buffer_append_u32(buffer, ((yp_numbered_reference_read_node_t *)node)->number);
1116
1290
  break;
1117
1291
  }
1118
- case YP_NODE_OPTIONAL_PARAMETER_NODE: {
1292
+ case YP_OPTIONAL_PARAMETER_NODE: {
1119
1293
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_optional_parameter_node_t *)node)->name));
1120
1294
  yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->name_loc, buffer);
1121
1295
  yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->operator_loc, buffer);
1122
1296
  yp_serialize_node(parser, (yp_node_t *)((yp_optional_parameter_node_t *)node)->value, buffer);
1123
1297
  break;
1124
1298
  }
1125
- case YP_NODE_OR_NODE: {
1299
+ case YP_OR_NODE: {
1126
1300
  yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->left, buffer);
1127
1301
  yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->right, buffer);
1128
1302
  yp_serialize_location(parser, &((yp_or_node_t *)node)->operator_loc, buffer);
1129
1303
  break;
1130
1304
  }
1131
- case YP_NODE_PARAMETERS_NODE: {
1305
+ case YP_PARAMETERS_NODE: {
1132
1306
  uint32_t requireds_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->requireds.size);
1133
1307
  yp_buffer_append_u32(buffer, requireds_size);
1134
1308
  for (uint32_t index = 0; index < requireds_size; index++) {
@@ -1139,16 +1313,16 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1139
1313
  for (uint32_t index = 0; index < optionals_size; index++) {
1140
1314
  yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->optionals.nodes[index], buffer);
1141
1315
  }
1142
- uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
1143
- yp_buffer_append_u32(buffer, posts_size);
1144
- for (uint32_t index = 0; index < posts_size; index++) {
1145
- yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
1146
- }
1147
1316
  if (((yp_parameters_node_t *)node)->rest == NULL) {
1148
1317
  yp_buffer_append_u8(buffer, 0);
1149
1318
  } else {
1150
1319
  yp_serialize_node(parser, (yp_node_t *)((yp_parameters_node_t *)node)->rest, buffer);
1151
1320
  }
1321
+ uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
1322
+ yp_buffer_append_u32(buffer, posts_size);
1323
+ for (uint32_t index = 0; index < posts_size; index++) {
1324
+ yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
1325
+ }
1152
1326
  uint32_t keywords_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->keywords.size);
1153
1327
  yp_buffer_append_u32(buffer, keywords_size);
1154
1328
  for (uint32_t index = 0; index < keywords_size; index++) {
@@ -1166,7 +1340,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1166
1340
  }
1167
1341
  break;
1168
1342
  }
1169
- case YP_NODE_PARENTHESES_NODE: {
1343
+ case YP_PARENTHESES_NODE: {
1170
1344
  if (((yp_parentheses_node_t *)node)->body == NULL) {
1171
1345
  yp_buffer_append_u8(buffer, 0);
1172
1346
  } else {
@@ -1176,19 +1350,19 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1176
1350
  yp_serialize_location(parser, &((yp_parentheses_node_t *)node)->closing_loc, buffer);
1177
1351
  break;
1178
1352
  }
1179
- case YP_NODE_PINNED_EXPRESSION_NODE: {
1353
+ case YP_PINNED_EXPRESSION_NODE: {
1180
1354
  yp_serialize_node(parser, (yp_node_t *)((yp_pinned_expression_node_t *)node)->expression, buffer);
1181
1355
  yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->operator_loc, buffer);
1182
1356
  yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->lparen_loc, buffer);
1183
1357
  yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->rparen_loc, buffer);
1184
1358
  break;
1185
1359
  }
1186
- case YP_NODE_PINNED_VARIABLE_NODE: {
1360
+ case YP_PINNED_VARIABLE_NODE: {
1187
1361
  yp_serialize_node(parser, (yp_node_t *)((yp_pinned_variable_node_t *)node)->variable, buffer);
1188
1362
  yp_serialize_location(parser, &((yp_pinned_variable_node_t *)node)->operator_loc, buffer);
1189
1363
  break;
1190
1364
  }
1191
- case YP_NODE_POST_EXECUTION_NODE: {
1365
+ case YP_POST_EXECUTION_NODE: {
1192
1366
  if (((yp_post_execution_node_t *)node)->statements == NULL) {
1193
1367
  yp_buffer_append_u8(buffer, 0);
1194
1368
  } else {
@@ -1199,7 +1373,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1199
1373
  yp_serialize_location(parser, &((yp_post_execution_node_t *)node)->closing_loc, buffer);
1200
1374
  break;
1201
1375
  }
1202
- case YP_NODE_PRE_EXECUTION_NODE: {
1376
+ case YP_PRE_EXECUTION_NODE: {
1203
1377
  if (((yp_pre_execution_node_t *)node)->statements == NULL) {
1204
1378
  yp_buffer_append_u8(buffer, 0);
1205
1379
  } else {
@@ -1210,7 +1384,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1210
1384
  yp_serialize_location(parser, &((yp_pre_execution_node_t *)node)->closing_loc, buffer);
1211
1385
  break;
1212
1386
  }
1213
- case YP_NODE_PROGRAM_NODE: {
1387
+ case YP_PROGRAM_NODE: {
1214
1388
  uint32_t locals_size = yp_sizet_to_u32(((yp_program_node_t *)node)->locals.size);
1215
1389
  yp_buffer_append_u32(buffer, locals_size);
1216
1390
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -1219,7 +1393,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1219
1393
  yp_serialize_node(parser, (yp_node_t *)((yp_program_node_t *)node)->statements, buffer);
1220
1394
  break;
1221
1395
  }
1222
- case YP_NODE_RANGE_NODE: {
1396
+ case YP_RANGE_NODE: {
1223
1397
  if (((yp_range_node_t *)node)->left == NULL) {
1224
1398
  yp_buffer_append_u8(buffer, 0);
1225
1399
  } else {
@@ -1231,25 +1405,25 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1231
1405
  yp_serialize_node(parser, (yp_node_t *)((yp_range_node_t *)node)->right, buffer);
1232
1406
  }
1233
1407
  yp_serialize_location(parser, &((yp_range_node_t *)node)->operator_loc, buffer);
1234
- yp_buffer_append_u32(buffer, node->flags >> 1);
1408
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1235
1409
  break;
1236
1410
  }
1237
- case YP_NODE_RATIONAL_NODE: {
1411
+ case YP_RATIONAL_NODE: {
1238
1412
  yp_serialize_node(parser, (yp_node_t *)((yp_rational_node_t *)node)->numeric, buffer);
1239
1413
  break;
1240
1414
  }
1241
- case YP_NODE_REDO_NODE: {
1415
+ case YP_REDO_NODE: {
1242
1416
  break;
1243
1417
  }
1244
- case YP_NODE_REGULAR_EXPRESSION_NODE: {
1418
+ case YP_REGULAR_EXPRESSION_NODE: {
1245
1419
  yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->opening_loc, buffer);
1246
1420
  yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->content_loc, buffer);
1247
1421
  yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->closing_loc, buffer);
1248
1422
  yp_serialize_string(parser, &((yp_regular_expression_node_t *)node)->unescaped, buffer);
1249
- yp_buffer_append_u32(buffer, node->flags >> 1);
1423
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1250
1424
  break;
1251
1425
  }
1252
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
1426
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
1253
1427
  uint32_t parameters_size = yp_sizet_to_u32(((yp_required_destructured_parameter_node_t *)node)->parameters.size);
1254
1428
  yp_buffer_append_u32(buffer, parameters_size);
1255
1429
  for (uint32_t index = 0; index < parameters_size; index++) {
@@ -1259,17 +1433,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1259
1433
  yp_serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->closing_loc, buffer);
1260
1434
  break;
1261
1435
  }
1262
- case YP_NODE_REQUIRED_PARAMETER_NODE: {
1436
+ case YP_REQUIRED_PARAMETER_NODE: {
1263
1437
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_required_parameter_node_t *)node)->name));
1264
1438
  break;
1265
1439
  }
1266
- case YP_NODE_RESCUE_MODIFIER_NODE: {
1440
+ case YP_RESCUE_MODIFIER_NODE: {
1267
1441
  yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression, buffer);
1268
1442
  yp_serialize_location(parser, &((yp_rescue_modifier_node_t *)node)->keyword_loc, buffer);
1269
1443
  yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression, buffer);
1270
1444
  break;
1271
1445
  }
1272
- case YP_NODE_RESCUE_NODE: {
1446
+ case YP_RESCUE_NODE: {
1273
1447
  yp_serialize_location(parser, &((yp_rescue_node_t *)node)->keyword_loc, buffer);
1274
1448
  uint32_t exceptions_size = yp_sizet_to_u32(((yp_rescue_node_t *)node)->exceptions.size);
1275
1449
  yp_buffer_append_u32(buffer, exceptions_size);
@@ -1299,20 +1473,21 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1299
1473
  }
1300
1474
  break;
1301
1475
  }
1302
- case YP_NODE_REST_PARAMETER_NODE: {
1303
- yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->operator_loc, buffer);
1476
+ case YP_REST_PARAMETER_NODE: {
1477
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_rest_parameter_node_t *)node)->name));
1304
1478
  if (((yp_rest_parameter_node_t *)node)->name_loc.start == NULL) {
1305
1479
  yp_buffer_append_u8(buffer, 0);
1306
1480
  } else {
1307
1481
  yp_buffer_append_u8(buffer, 1);
1308
1482
  yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->name_loc, buffer);
1309
1483
  }
1484
+ yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->operator_loc, buffer);
1310
1485
  break;
1311
1486
  }
1312
- case YP_NODE_RETRY_NODE: {
1487
+ case YP_RETRY_NODE: {
1313
1488
  break;
1314
1489
  }
1315
- case YP_NODE_RETURN_NODE: {
1490
+ case YP_RETURN_NODE: {
1316
1491
  yp_serialize_location(parser, &((yp_return_node_t *)node)->keyword_loc, buffer);
1317
1492
  if (((yp_return_node_t *)node)->arguments == NULL) {
1318
1493
  yp_buffer_append_u8(buffer, 0);
@@ -1321,10 +1496,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1321
1496
  }
1322
1497
  break;
1323
1498
  }
1324
- case YP_NODE_SELF_NODE: {
1499
+ case YP_SELF_NODE: {
1325
1500
  break;
1326
1501
  }
1327
- case YP_NODE_SINGLETON_CLASS_NODE: {
1502
+ case YP_SINGLETON_CLASS_NODE: {
1328
1503
  uint32_t locals_size = yp_sizet_to_u32(((yp_singleton_class_node_t *)node)->locals.size);
1329
1504
  yp_buffer_append_u32(buffer, locals_size);
1330
1505
  for (uint32_t index = 0; index < locals_size; index++) {
@@ -1341,17 +1516,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1341
1516
  yp_serialize_location(parser, &((yp_singleton_class_node_t *)node)->end_keyword_loc, buffer);
1342
1517
  break;
1343
1518
  }
1344
- case YP_NODE_SOURCE_ENCODING_NODE: {
1519
+ case YP_SOURCE_ENCODING_NODE: {
1345
1520
  break;
1346
1521
  }
1347
- case YP_NODE_SOURCE_FILE_NODE: {
1522
+ case YP_SOURCE_FILE_NODE: {
1348
1523
  yp_serialize_string(parser, &((yp_source_file_node_t *)node)->filepath, buffer);
1349
1524
  break;
1350
1525
  }
1351
- case YP_NODE_SOURCE_LINE_NODE: {
1526
+ case YP_SOURCE_LINE_NODE: {
1352
1527
  break;
1353
1528
  }
1354
- case YP_NODE_SPLAT_NODE: {
1529
+ case YP_SPLAT_NODE: {
1355
1530
  yp_serialize_location(parser, &((yp_splat_node_t *)node)->operator_loc, buffer);
1356
1531
  if (((yp_splat_node_t *)node)->expression == NULL) {
1357
1532
  yp_buffer_append_u8(buffer, 0);
@@ -1360,7 +1535,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1360
1535
  }
1361
1536
  break;
1362
1537
  }
1363
- case YP_NODE_STATEMENTS_NODE: {
1538
+ case YP_STATEMENTS_NODE: {
1364
1539
  uint32_t body_size = yp_sizet_to_u32(((yp_statements_node_t *)node)->body.size);
1365
1540
  yp_buffer_append_u32(buffer, body_size);
1366
1541
  for (uint32_t index = 0; index < body_size; index++) {
@@ -1368,12 +1543,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1368
1543
  }
1369
1544
  break;
1370
1545
  }
1371
- case YP_NODE_STRING_CONCAT_NODE: {
1546
+ case YP_STRING_CONCAT_NODE: {
1372
1547
  yp_serialize_node(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->left, buffer);
1373
1548
  yp_serialize_node(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->right, buffer);
1374
1549
  break;
1375
1550
  }
1376
- case YP_NODE_STRING_NODE: {
1551
+ case YP_STRING_NODE: {
1552
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1377
1553
  if (((yp_string_node_t *)node)->opening_loc.start == NULL) {
1378
1554
  yp_buffer_append_u8(buffer, 0);
1379
1555
  } else {
@@ -1390,7 +1566,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1390
1566
  yp_serialize_string(parser, &((yp_string_node_t *)node)->unescaped, buffer);
1391
1567
  break;
1392
1568
  }
1393
- case YP_NODE_SUPER_NODE: {
1569
+ case YP_SUPER_NODE: {
1394
1570
  yp_serialize_location(parser, &((yp_super_node_t *)node)->keyword_loc, buffer);
1395
1571
  if (((yp_super_node_t *)node)->lparen_loc.start == NULL) {
1396
1572
  yp_buffer_append_u8(buffer, 0);
@@ -1416,7 +1592,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1416
1592
  }
1417
1593
  break;
1418
1594
  }
1419
- case YP_NODE_SYMBOL_NODE: {
1595
+ case YP_SYMBOL_NODE: {
1420
1596
  if (((yp_symbol_node_t *)node)->opening_loc.start == NULL) {
1421
1597
  yp_buffer_append_u8(buffer, 0);
1422
1598
  } else {
@@ -1438,10 +1614,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1438
1614
  yp_serialize_string(parser, &((yp_symbol_node_t *)node)->unescaped, buffer);
1439
1615
  break;
1440
1616
  }
1441
- case YP_NODE_TRUE_NODE: {
1617
+ case YP_TRUE_NODE: {
1442
1618
  break;
1443
1619
  }
1444
- case YP_NODE_UNDEF_NODE: {
1620
+ case YP_UNDEF_NODE: {
1445
1621
  uint32_t names_size = yp_sizet_to_u32(((yp_undef_node_t *)node)->names.size);
1446
1622
  yp_buffer_append_u32(buffer, names_size);
1447
1623
  for (uint32_t index = 0; index < names_size; index++) {
@@ -1450,7 +1626,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1450
1626
  yp_serialize_location(parser, &((yp_undef_node_t *)node)->keyword_loc, buffer);
1451
1627
  break;
1452
1628
  }
1453
- case YP_NODE_UNLESS_NODE: {
1629
+ case YP_UNLESS_NODE: {
1454
1630
  yp_serialize_location(parser, &((yp_unless_node_t *)node)->keyword_loc, buffer);
1455
1631
  yp_serialize_node(parser, (yp_node_t *)((yp_unless_node_t *)node)->predicate, buffer);
1456
1632
  if (((yp_unless_node_t *)node)->statements == NULL) {
@@ -1471,7 +1647,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1471
1647
  }
1472
1648
  break;
1473
1649
  }
1474
- case YP_NODE_UNTIL_NODE: {
1650
+ case YP_UNTIL_NODE: {
1475
1651
  yp_serialize_location(parser, &((yp_until_node_t *)node)->keyword_loc, buffer);
1476
1652
  if (((yp_until_node_t *)node)->closing_loc.start == NULL) {
1477
1653
  yp_buffer_append_u8(buffer, 0);
@@ -1485,10 +1661,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1485
1661
  } else {
1486
1662
  yp_serialize_node(parser, (yp_node_t *)((yp_until_node_t *)node)->statements, buffer);
1487
1663
  }
1488
- yp_buffer_append_u32(buffer, node->flags >> 1);
1664
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1489
1665
  break;
1490
1666
  }
1491
- case YP_NODE_WHEN_NODE: {
1667
+ case YP_WHEN_NODE: {
1492
1668
  yp_serialize_location(parser, &((yp_when_node_t *)node)->keyword_loc, buffer);
1493
1669
  uint32_t conditions_size = yp_sizet_to_u32(((yp_when_node_t *)node)->conditions.size);
1494
1670
  yp_buffer_append_u32(buffer, conditions_size);
@@ -1502,7 +1678,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1502
1678
  }
1503
1679
  break;
1504
1680
  }
1505
- case YP_NODE_WHILE_NODE: {
1681
+ case YP_WHILE_NODE: {
1506
1682
  yp_serialize_location(parser, &((yp_while_node_t *)node)->keyword_loc, buffer);
1507
1683
  if (((yp_while_node_t *)node)->closing_loc.start == NULL) {
1508
1684
  yp_buffer_append_u8(buffer, 0);
@@ -1516,17 +1692,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1516
1692
  } else {
1517
1693
  yp_serialize_node(parser, (yp_node_t *)((yp_while_node_t *)node)->statements, buffer);
1518
1694
  }
1519
- yp_buffer_append_u32(buffer, node->flags >> 1);
1695
+ yp_buffer_append_u32(buffer, node->flags >> 2);
1520
1696
  break;
1521
1697
  }
1522
- case YP_NODE_X_STRING_NODE: {
1698
+ case YP_X_STRING_NODE: {
1523
1699
  yp_serialize_location(parser, &((yp_x_string_node_t *)node)->opening_loc, buffer);
1524
1700
  yp_serialize_location(parser, &((yp_x_string_node_t *)node)->content_loc, buffer);
1525
1701
  yp_serialize_location(parser, &((yp_x_string_node_t *)node)->closing_loc, buffer);
1526
1702
  yp_serialize_string(parser, &((yp_x_string_node_t *)node)->unescaped, buffer);
1527
1703
  break;
1528
1704
  }
1529
- case YP_NODE_YIELD_NODE: {
1705
+ case YP_YIELD_NODE: {
1530
1706
  yp_serialize_location(parser, &((yp_yield_node_t *)node)->keyword_loc, buffer);
1531
1707
  if (((yp_yield_node_t *)node)->lparen_loc.start == NULL) {
1532
1708
  yp_buffer_append_u8(buffer, 0);
@@ -1599,7 +1775,7 @@ yp_serialize_encoding(yp_encoding_t *encoding, yp_buffer_t *buffer) {
1599
1775
  yp_buffer_append_str(buffer, encoding->name, encoding_length);
1600
1776
  }
1601
1777
 
1602
- #line 181 "serialize.c.erb"
1778
+ #line 175 "serialize.c.erb"
1603
1779
  void
1604
1780
  yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1605
1781
  yp_serialize_encoding(&parser->encoding, buffer);
@@ -1634,12 +1810,31 @@ yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer)
1634
1810
  // If we find a constant at this index, serialize it at the correct
1635
1811
  // index in the buffer.
1636
1812
  if (constant->id != 0) {
1637
- size_t buffer_offset = offset + ((constant->id - 1) * 8);
1813
+ size_t buffer_offset = offset + ((((size_t) constant->id) - 1) * 8);
1638
1814
 
1639
- uint32_t source_offset = yp_ptrdifft_to_u32(constant->start - parser->start);
1640
- uint32_t constant_length = yp_sizet_to_u32(constant->length);
1815
+ if (constant->owned) {
1816
+ // Since this is an owned constant, we are going to write its
1817
+ // contents into the buffer after the constant pool. So
1818
+ // effectively in place of the source offset, we have a buffer
1819
+ // offset. We will add a leading 1 to indicate that this is a
1820
+ // buffer offset.
1821
+ uint32_t content_offset = yp_sizet_to_u32(buffer->length);
1822
+ uint32_t owned_mask = (uint32_t) (1 << 31);
1641
1823
 
1642
- memcpy(buffer->value + buffer_offset, &source_offset, 4);
1824
+ assert(content_offset < owned_mask);
1825
+ content_offset |= owned_mask;
1826
+
1827
+ memcpy(buffer->value + buffer_offset, &content_offset, 4);
1828
+ yp_buffer_append_bytes(buffer, constant->start, constant->length);
1829
+ } else {
1830
+ // Since this is a shared constant, we are going to write its
1831
+ // source offset directly into the buffer.
1832
+ uint32_t source_offset = yp_ptrdifft_to_u32(constant->start - parser->start);
1833
+ memcpy(buffer->value + buffer_offset, &source_offset, 4);
1834
+ }
1835
+
1836
+ // Now we can write the length of the constant into the buffer.
1837
+ uint32_t constant_length = yp_sizet_to_u32(constant->length);
1643
1838
  memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
1644
1839
  }
1645
1840
  }