yarp 0.8.0 → 0.10.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 (63) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +48 -1
  3. data/Makefile +5 -1
  4. data/README.md +4 -3
  5. data/config.yml +461 -150
  6. data/docs/configuration.md +1 -0
  7. data/docs/encoding.md +5 -5
  8. data/docs/ruby_api.md +2 -0
  9. data/docs/serialization.md +3 -3
  10. data/docs/testing.md +2 -2
  11. data/ext/yarp/api_node.c +810 -199
  12. data/ext/yarp/extension.c +94 -31
  13. data/ext/yarp/extension.h +2 -2
  14. data/include/yarp/ast.h +653 -150
  15. data/include/yarp/defines.h +2 -1
  16. data/include/yarp/diagnostic.h +3 -3
  17. data/include/yarp/enc/yp_encoding.h +10 -10
  18. data/include/yarp/node.h +10 -0
  19. data/include/yarp/parser.h +19 -19
  20. data/include/yarp/regexp.h +1 -1
  21. data/include/yarp/unescape.h +7 -5
  22. data/include/yarp/util/yp_buffer.h +3 -0
  23. data/include/yarp/util/yp_char.h +16 -16
  24. data/include/yarp/util/yp_constant_pool.h +2 -2
  25. data/include/yarp/util/yp_newline_list.h +7 -4
  26. data/include/yarp/util/yp_string.h +4 -4
  27. data/include/yarp/util/yp_string_list.h +0 -3
  28. data/include/yarp/util/yp_strpbrk.h +1 -1
  29. data/include/yarp/version.h +2 -2
  30. data/include/yarp.h +14 -3
  31. data/lib/yarp/desugar_visitor.rb +204 -0
  32. data/lib/yarp/ffi.rb +27 -1
  33. data/lib/yarp/lex_compat.rb +93 -25
  34. data/lib/yarp/mutation_visitor.rb +683 -0
  35. data/lib/yarp/node.rb +3121 -597
  36. data/lib/yarp/serialize.rb +198 -126
  37. data/lib/yarp.rb +53 -7
  38. data/src/diagnostic.c +1 -1
  39. data/src/enc/yp_big5.c +15 -42
  40. data/src/enc/yp_euc_jp.c +16 -43
  41. data/src/enc/yp_gbk.c +19 -46
  42. data/src/enc/yp_shift_jis.c +16 -43
  43. data/src/enc/yp_tables.c +36 -38
  44. data/src/enc/yp_unicode.c +20 -25
  45. data/src/enc/yp_windows_31j.c +16 -43
  46. data/src/node.c +1444 -836
  47. data/src/prettyprint.c +324 -103
  48. data/src/regexp.c +21 -21
  49. data/src/serialize.c +429 -276
  50. data/src/token_type.c +2 -2
  51. data/src/unescape.c +184 -136
  52. data/src/util/yp_buffer.c +7 -2
  53. data/src/util/yp_char.c +34 -34
  54. data/src/util/yp_constant_pool.c +4 -4
  55. data/src/util/yp_memchr.c +1 -1
  56. data/src/util/yp_newline_list.c +14 -3
  57. data/src/util/yp_string.c +22 -20
  58. data/src/util/yp_string_list.c +0 -6
  59. data/src/util/yp_strncasecmp.c +3 -6
  60. data/src/util/yp_strpbrk.c +8 -8
  61. data/src/yarp.c +1504 -615
  62. data/yarp.gemspec +3 -1
  63. metadata +4 -2
data/src/serialize.c CHANGED
@@ -1,6 +1,6 @@
1
1
  /******************************************************************************/
2
- /* This file is generated by the bin/template script and should not be */
3
- /* modified manually. See */
2
+ /* This file is generated by the templates/template.rb script and should not */
3
+ /* be modified manually. See */
4
4
  /* templates/src/serialize.c.erb */
5
5
  /* if you are looking to modify the */
6
6
  /* template */
@@ -22,7 +22,7 @@ yp_sizet_to_u32(size_t value) {
22
22
  }
23
23
 
24
24
  static void
25
- serialize_location(yp_parser_t *parser, yp_location_t *location, yp_buffer_t *buffer) {
25
+ yp_serialize_location(yp_parser_t *parser, yp_location_t *location, yp_buffer_t *buffer) {
26
26
  assert(location->start);
27
27
  assert(location->end);
28
28
  assert(location->start <= location->end);
@@ -31,37 +31,58 @@ serialize_location(yp_parser_t *parser, yp_location_t *location, yp_buffer_t *bu
31
31
  yp_buffer_append_u32(buffer, yp_ptrdifft_to_u32(location->end - location->start));
32
32
  }
33
33
 
34
+ static void
35
+ yp_serialize_string(yp_parser_t *parser, yp_string_t *string, yp_buffer_t *buffer) {
36
+ switch (string->type) {
37
+ case YP_STRING_SHARED: {
38
+ yp_buffer_append_u8(buffer, 1);
39
+ yp_buffer_append_u32(buffer, yp_ptrdifft_to_u32(yp_string_source(string) - parser->start));
40
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_string_length(string)));
41
+ break;
42
+ }
43
+ case YP_STRING_OWNED:
44
+ case YP_STRING_CONSTANT: {
45
+ uint32_t length = yp_sizet_to_u32(yp_string_length(string));
46
+ yp_buffer_append_u8(buffer, 2);
47
+ yp_buffer_append_u32(buffer, length);
48
+ yp_buffer_append_bytes(buffer, yp_string_source(string), length);
49
+ break;
50
+ }
51
+ case YP_STRING_MAPPED:
52
+ assert(false && "Cannot serialize mapped strings.");
53
+ break;
54
+ }
55
+ }
56
+
34
57
  void
35
58
  yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
36
59
  yp_buffer_append_u8(buffer, (uint8_t) YP_NODE_TYPE(node));
37
60
 
38
61
  size_t offset = buffer->length;
39
62
 
40
- serialize_location(parser, &node->location, buffer);
63
+ yp_serialize_location(parser, &node->location, buffer);
41
64
 
42
65
  switch (YP_NODE_TYPE(node)) {
66
+ // We do not need to serialize a ScopeNode ever as
67
+ // it is not part of the AST
68
+ case YP_NODE_SCOPE_NODE:
69
+ return;
43
70
  case YP_NODE_ALIAS_NODE: {
44
71
  yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->new_name, buffer);
45
72
  yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->old_name, buffer);
46
- serialize_location(parser, &((yp_alias_node_t *)node)->keyword_loc, buffer);
73
+ yp_serialize_location(parser, &((yp_alias_node_t *)node)->keyword_loc, buffer);
47
74
  break;
48
75
  }
49
76
  case YP_NODE_ALTERNATION_PATTERN_NODE: {
50
77
  yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->left, buffer);
51
78
  yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->right, buffer);
52
- serialize_location(parser, &((yp_alternation_pattern_node_t *)node)->operator_loc, buffer);
79
+ yp_serialize_location(parser, &((yp_alternation_pattern_node_t *)node)->operator_loc, buffer);
53
80
  break;
54
81
  }
55
82
  case YP_NODE_AND_NODE: {
56
83
  yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->left, buffer);
57
84
  yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->right, buffer);
58
- serialize_location(parser, &((yp_and_node_t *)node)->operator_loc, buffer);
59
- break;
60
- }
61
- case YP_NODE_AND_WRITE_NODE: {
62
- yp_serialize_node(parser, (yp_node_t *)((yp_and_write_node_t *)node)->target, buffer);
63
- yp_serialize_node(parser, (yp_node_t *)((yp_and_write_node_t *)node)->value, buffer);
64
- serialize_location(parser, &((yp_and_write_node_t *)node)->operator_loc, buffer);
85
+ yp_serialize_location(parser, &((yp_and_node_t *)node)->operator_loc, buffer);
65
86
  break;
66
87
  }
67
88
  case YP_NODE_ARGUMENTS_NODE: {
@@ -82,13 +103,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
82
103
  yp_buffer_append_u8(buffer, 0);
83
104
  } else {
84
105
  yp_buffer_append_u8(buffer, 1);
85
- serialize_location(parser, &((yp_array_node_t *)node)->opening_loc, buffer);
106
+ yp_serialize_location(parser, &((yp_array_node_t *)node)->opening_loc, buffer);
86
107
  }
87
108
  if (((yp_array_node_t *)node)->closing_loc.start == NULL) {
88
109
  yp_buffer_append_u8(buffer, 0);
89
110
  } else {
90
111
  yp_buffer_append_u8(buffer, 1);
91
- serialize_location(parser, &((yp_array_node_t *)node)->closing_loc, buffer);
112
+ yp_serialize_location(parser, &((yp_array_node_t *)node)->closing_loc, buffer);
92
113
  }
93
114
  break;
94
115
  }
@@ -117,13 +138,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
117
138
  yp_buffer_append_u8(buffer, 0);
118
139
  } else {
119
140
  yp_buffer_append_u8(buffer, 1);
120
- serialize_location(parser, &((yp_array_pattern_node_t *)node)->opening_loc, buffer);
141
+ yp_serialize_location(parser, &((yp_array_pattern_node_t *)node)->opening_loc, buffer);
121
142
  }
122
143
  if (((yp_array_pattern_node_t *)node)->closing_loc.start == NULL) {
123
144
  yp_buffer_append_u8(buffer, 0);
124
145
  } else {
125
146
  yp_buffer_append_u8(buffer, 1);
126
- serialize_location(parser, &((yp_array_pattern_node_t *)node)->closing_loc, buffer);
147
+ yp_serialize_location(parser, &((yp_array_pattern_node_t *)node)->closing_loc, buffer);
127
148
  }
128
149
  break;
129
150
  }
@@ -138,7 +159,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
138
159
  yp_buffer_append_u8(buffer, 0);
139
160
  } else {
140
161
  yp_buffer_append_u8(buffer, 1);
141
- serialize_location(parser, &((yp_assoc_node_t *)node)->operator_loc, buffer);
162
+ yp_serialize_location(parser, &((yp_assoc_node_t *)node)->operator_loc, buffer);
142
163
  }
143
164
  break;
144
165
  }
@@ -148,7 +169,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
148
169
  } else {
149
170
  yp_serialize_node(parser, (yp_node_t *)((yp_assoc_splat_node_t *)node)->value, buffer);
150
171
  }
151
- serialize_location(parser, &((yp_assoc_splat_node_t *)node)->operator_loc, buffer);
172
+ yp_serialize_location(parser, &((yp_assoc_splat_node_t *)node)->operator_loc, buffer);
152
173
  break;
153
174
  }
154
175
  case YP_NODE_BACK_REFERENCE_READ_NODE: {
@@ -159,7 +180,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
159
180
  yp_buffer_append_u8(buffer, 0);
160
181
  } else {
161
182
  yp_buffer_append_u8(buffer, 1);
162
- serialize_location(parser, &((yp_begin_node_t *)node)->begin_keyword_loc, buffer);
183
+ yp_serialize_location(parser, &((yp_begin_node_t *)node)->begin_keyword_loc, buffer);
163
184
  }
164
185
  if (((yp_begin_node_t *)node)->statements == NULL) {
165
186
  yp_buffer_append_u8(buffer, 0);
@@ -185,7 +206,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
185
206
  yp_buffer_append_u8(buffer, 0);
186
207
  } else {
187
208
  yp_buffer_append_u8(buffer, 1);
188
- serialize_location(parser, &((yp_begin_node_t *)node)->end_keyword_loc, buffer);
209
+ yp_serialize_location(parser, &((yp_begin_node_t *)node)->end_keyword_loc, buffer);
189
210
  }
190
211
  break;
191
212
  }
@@ -195,7 +216,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
195
216
  } else {
196
217
  yp_serialize_node(parser, (yp_node_t *)((yp_block_argument_node_t *)node)->expression, buffer);
197
218
  }
198
- serialize_location(parser, &((yp_block_argument_node_t *)node)->operator_loc, buffer);
219
+ yp_serialize_location(parser, &((yp_block_argument_node_t *)node)->operator_loc, buffer);
199
220
  break;
200
221
  }
201
222
  case YP_NODE_BLOCK_NODE: {
@@ -214,8 +235,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
214
235
  } else {
215
236
  yp_serialize_node(parser, (yp_node_t *)((yp_block_node_t *)node)->body, buffer);
216
237
  }
217
- serialize_location(parser, &((yp_block_node_t *)node)->opening_loc, buffer);
218
- serialize_location(parser, &((yp_block_node_t *)node)->closing_loc, buffer);
238
+ yp_serialize_location(parser, &((yp_block_node_t *)node)->opening_loc, buffer);
239
+ yp_serialize_location(parser, &((yp_block_node_t *)node)->closing_loc, buffer);
219
240
  break;
220
241
  }
221
242
  case YP_NODE_BLOCK_PARAMETER_NODE: {
@@ -223,9 +244,9 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
223
244
  yp_buffer_append_u8(buffer, 0);
224
245
  } else {
225
246
  yp_buffer_append_u8(buffer, 1);
226
- serialize_location(parser, &((yp_block_parameter_node_t *)node)->name_loc, buffer);
247
+ yp_serialize_location(parser, &((yp_block_parameter_node_t *)node)->name_loc, buffer);
227
248
  }
228
- serialize_location(parser, &((yp_block_parameter_node_t *)node)->operator_loc, buffer);
249
+ yp_serialize_location(parser, &((yp_block_parameter_node_t *)node)->operator_loc, buffer);
229
250
  break;
230
251
  }
231
252
  case YP_NODE_BLOCK_PARAMETERS_NODE: {
@@ -237,19 +258,19 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
237
258
  uint32_t locals_size = yp_sizet_to_u32(((yp_block_parameters_node_t *)node)->locals.size);
238
259
  yp_buffer_append_u32(buffer, locals_size);
239
260
  for (uint32_t index = 0; index < locals_size; index++) {
240
- serialize_location(parser, &((yp_block_parameters_node_t *)node)->locals.locations[index], buffer);
261
+ yp_serialize_location(parser, &((yp_block_parameters_node_t *)node)->locals.locations[index], buffer);
241
262
  }
242
263
  if (((yp_block_parameters_node_t *)node)->opening_loc.start == NULL) {
243
264
  yp_buffer_append_u8(buffer, 0);
244
265
  } else {
245
266
  yp_buffer_append_u8(buffer, 1);
246
- serialize_location(parser, &((yp_block_parameters_node_t *)node)->opening_loc, buffer);
267
+ yp_serialize_location(parser, &((yp_block_parameters_node_t *)node)->opening_loc, buffer);
247
268
  }
248
269
  if (((yp_block_parameters_node_t *)node)->closing_loc.start == NULL) {
249
270
  yp_buffer_append_u8(buffer, 0);
250
271
  } else {
251
272
  yp_buffer_append_u8(buffer, 1);
252
- serialize_location(parser, &((yp_block_parameters_node_t *)node)->closing_loc, buffer);
273
+ yp_serialize_location(parser, &((yp_block_parameters_node_t *)node)->closing_loc, buffer);
253
274
  }
254
275
  break;
255
276
  }
@@ -259,7 +280,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
259
280
  } else {
260
281
  yp_serialize_node(parser, (yp_node_t *)((yp_break_node_t *)node)->arguments, buffer);
261
282
  }
262
- serialize_location(parser, &((yp_break_node_t *)node)->keyword_loc, buffer);
283
+ yp_serialize_location(parser, &((yp_break_node_t *)node)->keyword_loc, buffer);
263
284
  break;
264
285
  }
265
286
  case YP_NODE_CALL_NODE: {
@@ -272,19 +293,19 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
272
293
  yp_buffer_append_u8(buffer, 0);
273
294
  } else {
274
295
  yp_buffer_append_u8(buffer, 1);
275
- serialize_location(parser, &((yp_call_node_t *)node)->operator_loc, buffer);
296
+ yp_serialize_location(parser, &((yp_call_node_t *)node)->operator_loc, buffer);
276
297
  }
277
298
  if (((yp_call_node_t *)node)->message_loc.start == NULL) {
278
299
  yp_buffer_append_u8(buffer, 0);
279
300
  } else {
280
301
  yp_buffer_append_u8(buffer, 1);
281
- serialize_location(parser, &((yp_call_node_t *)node)->message_loc, buffer);
302
+ yp_serialize_location(parser, &((yp_call_node_t *)node)->message_loc, buffer);
282
303
  }
283
304
  if (((yp_call_node_t *)node)->opening_loc.start == NULL) {
284
305
  yp_buffer_append_u8(buffer, 0);
285
306
  } else {
286
307
  yp_buffer_append_u8(buffer, 1);
287
- serialize_location(parser, &((yp_call_node_t *)node)->opening_loc, buffer);
308
+ yp_serialize_location(parser, &((yp_call_node_t *)node)->opening_loc, buffer);
288
309
  }
289
310
  if (((yp_call_node_t *)node)->arguments == NULL) {
290
311
  yp_buffer_append_u8(buffer, 0);
@@ -295,7 +316,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
295
316
  yp_buffer_append_u8(buffer, 0);
296
317
  } else {
297
318
  yp_buffer_append_u8(buffer, 1);
298
- serialize_location(parser, &((yp_call_node_t *)node)->closing_loc, buffer);
319
+ yp_serialize_location(parser, &((yp_call_node_t *)node)->closing_loc, buffer);
299
320
  }
300
321
  if (((yp_call_node_t *)node)->block == NULL) {
301
322
  yp_buffer_append_u8(buffer, 0);
@@ -303,34 +324,32 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
303
324
  yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->block, buffer);
304
325
  }
305
326
  yp_buffer_append_u32(buffer, node->flags >> 1);
306
- uint32_t name_length = yp_sizet_to_u32(yp_string_length(&((yp_call_node_t *)node)->name));
307
- yp_buffer_append_u32(buffer, name_length);
308
- yp_buffer_append_str(buffer, yp_string_source(&((yp_call_node_t *)node)->name), name_length);
327
+ yp_serialize_string(parser, &((yp_call_node_t *)node)->name, buffer);
309
328
  break;
310
329
  }
311
330
  case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
312
331
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->target, buffer);
313
- serialize_location(parser, &((yp_call_operator_and_write_node_t *)node)->operator_loc, buffer);
332
+ yp_serialize_location(parser, &((yp_call_operator_and_write_node_t *)node)->operator_loc, buffer);
314
333
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->value, buffer);
315
334
  break;
316
335
  }
317
336
  case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
318
337
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->target, buffer);
319
338
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->value, buffer);
320
- serialize_location(parser, &((yp_call_operator_or_write_node_t *)node)->operator_loc, buffer);
339
+ yp_serialize_location(parser, &((yp_call_operator_or_write_node_t *)node)->operator_loc, buffer);
321
340
  break;
322
341
  }
323
342
  case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
324
343
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->target, buffer);
325
- serialize_location(parser, &((yp_call_operator_write_node_t *)node)->operator_loc, buffer);
344
+ yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->operator_loc, buffer);
326
345
  yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->value, buffer);
327
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator_id));
346
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
328
347
  break;
329
348
  }
330
349
  case YP_NODE_CAPTURE_PATTERN_NODE: {
331
350
  yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->value, buffer);
332
351
  yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->target, buffer);
333
- serialize_location(parser, &((yp_capture_pattern_node_t *)node)->operator_loc, buffer);
352
+ yp_serialize_location(parser, &((yp_capture_pattern_node_t *)node)->operator_loc, buffer);
334
353
  break;
335
354
  }
336
355
  case YP_NODE_CASE_NODE: {
@@ -349,8 +368,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
349
368
  } else {
350
369
  yp_serialize_node(parser, (yp_node_t *)((yp_case_node_t *)node)->consequent, buffer);
351
370
  }
352
- serialize_location(parser, &((yp_case_node_t *)node)->case_keyword_loc, buffer);
353
- serialize_location(parser, &((yp_case_node_t *)node)->end_keyword_loc, buffer);
371
+ yp_serialize_location(parser, &((yp_case_node_t *)node)->case_keyword_loc, buffer);
372
+ yp_serialize_location(parser, &((yp_case_node_t *)node)->end_keyword_loc, buffer);
354
373
  break;
355
374
  }
356
375
  case YP_NODE_CLASS_NODE: {
@@ -359,13 +378,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
359
378
  for (uint32_t index = 0; index < locals_size; index++) {
360
379
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_node_t *)node)->locals.ids[index]));
361
380
  }
362
- serialize_location(parser, &((yp_class_node_t *)node)->class_keyword_loc, buffer);
381
+ yp_serialize_location(parser, &((yp_class_node_t *)node)->class_keyword_loc, buffer);
363
382
  yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->constant_path, buffer);
364
383
  if (((yp_class_node_t *)node)->inheritance_operator_loc.start == NULL) {
365
384
  yp_buffer_append_u8(buffer, 0);
366
385
  } else {
367
386
  yp_buffer_append_u8(buffer, 1);
368
- serialize_location(parser, &((yp_class_node_t *)node)->inheritance_operator_loc, buffer);
387
+ yp_serialize_location(parser, &((yp_class_node_t *)node)->inheritance_operator_loc, buffer);
369
388
  }
370
389
  if (((yp_class_node_t *)node)->superclass == NULL) {
371
390
  yp_buffer_append_u8(buffer, 0);
@@ -377,14 +396,43 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
377
396
  } else {
378
397
  yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->body, buffer);
379
398
  }
380
- serialize_location(parser, &((yp_class_node_t *)node)->end_keyword_loc, buffer);
399
+ 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);
401
+ break;
402
+ }
403
+ case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
404
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_and_write_node_t *)node)->name));
405
+ yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->name_loc, buffer);
406
+ yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->operator_loc, buffer);
407
+ yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value, buffer);
408
+ break;
409
+ }
410
+ case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
411
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->name));
412
+ yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->name_loc, buffer);
413
+ yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->operator_loc, buffer);
414
+ yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value, buffer);
415
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->operator));
416
+ break;
417
+ }
418
+ case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
419
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_or_write_node_t *)node)->name));
420
+ yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->name_loc, buffer);
421
+ yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->operator_loc, buffer);
422
+ yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value, buffer);
381
423
  break;
382
424
  }
383
425
  case YP_NODE_CLASS_VARIABLE_READ_NODE: {
426
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_read_node_t *)node)->name));
427
+ break;
428
+ }
429
+ case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
430
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_target_node_t *)node)->name));
384
431
  break;
385
432
  }
386
433
  case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
387
- serialize_location(parser, &((yp_class_variable_write_node_t *)node)->name_loc, buffer);
434
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_write_node_t *)node)->name));
435
+ yp_serialize_location(parser, &((yp_class_variable_write_node_t *)node)->name_loc, buffer);
388
436
  if (((yp_class_variable_write_node_t *)node)->value == NULL) {
389
437
  yp_buffer_append_u8(buffer, 0);
390
438
  } else {
@@ -394,10 +442,35 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
394
442
  yp_buffer_append_u8(buffer, 0);
395
443
  } else {
396
444
  yp_buffer_append_u8(buffer, 1);
397
- serialize_location(parser, &((yp_class_variable_write_node_t *)node)->operator_loc, buffer);
445
+ yp_serialize_location(parser, &((yp_class_variable_write_node_t *)node)->operator_loc, buffer);
398
446
  }
399
447
  break;
400
448
  }
449
+ case YP_NODE_CONSTANT_AND_WRITE_NODE: {
450
+ yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->name_loc, buffer);
451
+ yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->operator_loc, buffer);
452
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_and_write_node_t *)node)->value, buffer);
453
+ break;
454
+ }
455
+ case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
456
+ yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->name_loc, buffer);
457
+ yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->operator_loc, buffer);
458
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, buffer);
459
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->operator));
460
+ break;
461
+ }
462
+ case YP_NODE_CONSTANT_OR_WRITE_NODE: {
463
+ yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->name_loc, buffer);
464
+ yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->operator_loc, buffer);
465
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_or_write_node_t *)node)->value, buffer);
466
+ break;
467
+ }
468
+ case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
469
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target, buffer);
470
+ yp_serialize_location(parser, &((yp_constant_path_and_write_node_t *)node)->operator_loc, buffer);
471
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value, buffer);
472
+ break;
473
+ }
401
474
  case YP_NODE_CONSTANT_PATH_NODE: {
402
475
  if (((yp_constant_path_node_t *)node)->parent == NULL) {
403
476
  yp_buffer_append_u8(buffer, 0);
@@ -405,40 +478,48 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
405
478
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_node_t *)node)->parent, buffer);
406
479
  }
407
480
  yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_node_t *)node)->child, buffer);
408
- serialize_location(parser, &((yp_constant_path_node_t *)node)->delimiter_loc, buffer);
481
+ yp_serialize_location(parser, &((yp_constant_path_node_t *)node)->delimiter_loc, buffer);
409
482
  break;
410
483
  }
411
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
412
- yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target, buffer);
413
- if (((yp_constant_path_write_node_t *)node)->operator_loc.start == NULL) {
414
- yp_buffer_append_u8(buffer, 0);
415
- } else {
416
- yp_buffer_append_u8(buffer, 1);
417
- serialize_location(parser, &((yp_constant_path_write_node_t *)node)->operator_loc, buffer);
418
- }
419
- if (((yp_constant_path_write_node_t *)node)->value == NULL) {
484
+ case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
485
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, buffer);
486
+ yp_serialize_location(parser, &((yp_constant_path_operator_write_node_t *)node)->operator_loc, buffer);
487
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, buffer);
488
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_path_operator_write_node_t *)node)->operator));
489
+ break;
490
+ }
491
+ case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
492
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target, buffer);
493
+ yp_serialize_location(parser, &((yp_constant_path_or_write_node_t *)node)->operator_loc, buffer);
494
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value, buffer);
495
+ break;
496
+ }
497
+ case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
498
+ if (((yp_constant_path_target_node_t *)node)->parent == NULL) {
420
499
  yp_buffer_append_u8(buffer, 0);
421
500
  } else {
422
- yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value, buffer);
501
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->parent, buffer);
423
502
  }
503
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->child, buffer);
504
+ yp_serialize_location(parser, &((yp_constant_path_target_node_t *)node)->delimiter_loc, buffer);
505
+ break;
506
+ }
507
+ case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
508
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target, buffer);
509
+ yp_serialize_location(parser, &((yp_constant_path_write_node_t *)node)->operator_loc, buffer);
510
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value, buffer);
424
511
  break;
425
512
  }
426
513
  case YP_NODE_CONSTANT_READ_NODE: {
427
514
  break;
428
515
  }
516
+ case YP_NODE_CONSTANT_TARGET_NODE: {
517
+ break;
518
+ }
429
519
  case YP_NODE_CONSTANT_WRITE_NODE: {
430
- serialize_location(parser, &((yp_constant_write_node_t *)node)->name_loc, buffer);
431
- if (((yp_constant_write_node_t *)node)->value == NULL) {
432
- yp_buffer_append_u8(buffer, 0);
433
- } else {
434
- yp_serialize_node(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value, buffer);
435
- }
436
- if (((yp_constant_write_node_t *)node)->operator_loc.start == NULL) {
437
- yp_buffer_append_u8(buffer, 0);
438
- } else {
439
- yp_buffer_append_u8(buffer, 1);
440
- serialize_location(parser, &((yp_constant_write_node_t *)node)->operator_loc, buffer);
441
- }
520
+ yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->name_loc, buffer);
521
+ yp_serialize_node(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value, buffer);
522
+ yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->operator_loc, buffer);
442
523
  break;
443
524
  }
444
525
  case YP_NODE_DEF_NODE: {
@@ -446,7 +527,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
446
527
  // encoding of location u32s make us need to save this offset.
447
528
  size_t length_offset = buffer->length;
448
529
  yp_buffer_append_str(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
449
- serialize_location(parser, &((yp_def_node_t *)node)->name_loc, buffer);
530
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->name_loc, buffer);
450
531
  if (((yp_def_node_t *)node)->receiver == NULL) {
451
532
  yp_buffer_append_u8(buffer, 0);
452
533
  } else {
@@ -467,36 +548,36 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
467
548
  for (uint32_t index = 0; index < locals_size; index++) {
468
549
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_def_node_t *)node)->locals.ids[index]));
469
550
  }
470
- serialize_location(parser, &((yp_def_node_t *)node)->def_keyword_loc, buffer);
551
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->def_keyword_loc, buffer);
471
552
  if (((yp_def_node_t *)node)->operator_loc.start == NULL) {
472
553
  yp_buffer_append_u8(buffer, 0);
473
554
  } else {
474
555
  yp_buffer_append_u8(buffer, 1);
475
- serialize_location(parser, &((yp_def_node_t *)node)->operator_loc, buffer);
556
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->operator_loc, buffer);
476
557
  }
477
558
  if (((yp_def_node_t *)node)->lparen_loc.start == NULL) {
478
559
  yp_buffer_append_u8(buffer, 0);
479
560
  } else {
480
561
  yp_buffer_append_u8(buffer, 1);
481
- serialize_location(parser, &((yp_def_node_t *)node)->lparen_loc, buffer);
562
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->lparen_loc, buffer);
482
563
  }
483
564
  if (((yp_def_node_t *)node)->rparen_loc.start == NULL) {
484
565
  yp_buffer_append_u8(buffer, 0);
485
566
  } else {
486
567
  yp_buffer_append_u8(buffer, 1);
487
- serialize_location(parser, &((yp_def_node_t *)node)->rparen_loc, buffer);
568
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->rparen_loc, buffer);
488
569
  }
489
570
  if (((yp_def_node_t *)node)->equal_loc.start == NULL) {
490
571
  yp_buffer_append_u8(buffer, 0);
491
572
  } else {
492
573
  yp_buffer_append_u8(buffer, 1);
493
- serialize_location(parser, &((yp_def_node_t *)node)->equal_loc, buffer);
574
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->equal_loc, buffer);
494
575
  }
495
576
  if (((yp_def_node_t *)node)->end_keyword_loc.start == NULL) {
496
577
  yp_buffer_append_u8(buffer, 0);
497
578
  } else {
498
579
  yp_buffer_append_u8(buffer, 1);
499
- serialize_location(parser, &((yp_def_node_t *)node)->end_keyword_loc, buffer);
580
+ yp_serialize_location(parser, &((yp_def_node_t *)node)->end_keyword_loc, buffer);
500
581
  }
501
582
  // serialize length
502
583
  uint32_t length = yp_sizet_to_u32(buffer->length - offset - sizeof(uint32_t));
@@ -508,20 +589,20 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
508
589
  yp_buffer_append_u8(buffer, 0);
509
590
  } else {
510
591
  yp_buffer_append_u8(buffer, 1);
511
- serialize_location(parser, &((yp_defined_node_t *)node)->lparen_loc, buffer);
592
+ yp_serialize_location(parser, &((yp_defined_node_t *)node)->lparen_loc, buffer);
512
593
  }
513
594
  yp_serialize_node(parser, (yp_node_t *)((yp_defined_node_t *)node)->value, buffer);
514
595
  if (((yp_defined_node_t *)node)->rparen_loc.start == NULL) {
515
596
  yp_buffer_append_u8(buffer, 0);
516
597
  } else {
517
598
  yp_buffer_append_u8(buffer, 1);
518
- serialize_location(parser, &((yp_defined_node_t *)node)->rparen_loc, buffer);
599
+ yp_serialize_location(parser, &((yp_defined_node_t *)node)->rparen_loc, buffer);
519
600
  }
520
- serialize_location(parser, &((yp_defined_node_t *)node)->keyword_loc, buffer);
601
+ yp_serialize_location(parser, &((yp_defined_node_t *)node)->keyword_loc, buffer);
521
602
  break;
522
603
  }
523
604
  case YP_NODE_ELSE_NODE: {
524
- serialize_location(parser, &((yp_else_node_t *)node)->else_keyword_loc, buffer);
605
+ yp_serialize_location(parser, &((yp_else_node_t *)node)->else_keyword_loc, buffer);
525
606
  if (((yp_else_node_t *)node)->statements == NULL) {
526
607
  yp_buffer_append_u8(buffer, 0);
527
608
  } else {
@@ -531,33 +612,33 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
531
612
  yp_buffer_append_u8(buffer, 0);
532
613
  } else {
533
614
  yp_buffer_append_u8(buffer, 1);
534
- serialize_location(parser, &((yp_else_node_t *)node)->end_keyword_loc, buffer);
615
+ yp_serialize_location(parser, &((yp_else_node_t *)node)->end_keyword_loc, buffer);
535
616
  }
536
617
  break;
537
618
  }
538
619
  case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
539
- serialize_location(parser, &((yp_embedded_statements_node_t *)node)->opening_loc, buffer);
620
+ yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->opening_loc, buffer);
540
621
  if (((yp_embedded_statements_node_t *)node)->statements == NULL) {
541
622
  yp_buffer_append_u8(buffer, 0);
542
623
  } else {
543
624
  yp_serialize_node(parser, (yp_node_t *)((yp_embedded_statements_node_t *)node)->statements, buffer);
544
625
  }
545
- serialize_location(parser, &((yp_embedded_statements_node_t *)node)->closing_loc, buffer);
626
+ yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->closing_loc, buffer);
546
627
  break;
547
628
  }
548
629
  case YP_NODE_EMBEDDED_VARIABLE_NODE: {
549
- serialize_location(parser, &((yp_embedded_variable_node_t *)node)->operator_loc, buffer);
630
+ yp_serialize_location(parser, &((yp_embedded_variable_node_t *)node)->operator_loc, buffer);
550
631
  yp_serialize_node(parser, (yp_node_t *)((yp_embedded_variable_node_t *)node)->variable, buffer);
551
632
  break;
552
633
  }
553
634
  case YP_NODE_ENSURE_NODE: {
554
- serialize_location(parser, &((yp_ensure_node_t *)node)->ensure_keyword_loc, buffer);
635
+ yp_serialize_location(parser, &((yp_ensure_node_t *)node)->ensure_keyword_loc, buffer);
555
636
  if (((yp_ensure_node_t *)node)->statements == NULL) {
556
637
  yp_buffer_append_u8(buffer, 0);
557
638
  } else {
558
639
  yp_serialize_node(parser, (yp_node_t *)((yp_ensure_node_t *)node)->statements, buffer);
559
640
  }
560
- serialize_location(parser, &((yp_ensure_node_t *)node)->end_keyword_loc, buffer);
641
+ yp_serialize_location(parser, &((yp_ensure_node_t *)node)->end_keyword_loc, buffer);
561
642
  break;
562
643
  }
563
644
  case YP_NODE_FALSE_NODE: {
@@ -580,13 +661,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
580
661
  yp_buffer_append_u8(buffer, 0);
581
662
  } else {
582
663
  yp_buffer_append_u8(buffer, 1);
583
- serialize_location(parser, &((yp_find_pattern_node_t *)node)->opening_loc, buffer);
664
+ yp_serialize_location(parser, &((yp_find_pattern_node_t *)node)->opening_loc, buffer);
584
665
  }
585
666
  if (((yp_find_pattern_node_t *)node)->closing_loc.start == NULL) {
586
667
  yp_buffer_append_u8(buffer, 0);
587
668
  } else {
588
669
  yp_buffer_append_u8(buffer, 1);
589
- serialize_location(parser, &((yp_find_pattern_node_t *)node)->closing_loc, buffer);
670
+ yp_serialize_location(parser, &((yp_find_pattern_node_t *)node)->closing_loc, buffer);
590
671
  }
591
672
  break;
592
673
  }
@@ -601,7 +682,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
601
682
  } else {
602
683
  yp_serialize_node(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->right, buffer);
603
684
  }
604
- serialize_location(parser, &((yp_flip_flop_node_t *)node)->operator_loc, buffer);
685
+ yp_serialize_location(parser, &((yp_flip_flop_node_t *)node)->operator_loc, buffer);
605
686
  yp_buffer_append_u32(buffer, node->flags >> 1);
606
687
  break;
607
688
  }
@@ -616,15 +697,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
616
697
  } else {
617
698
  yp_serialize_node(parser, (yp_node_t *)((yp_for_node_t *)node)->statements, buffer);
618
699
  }
619
- serialize_location(parser, &((yp_for_node_t *)node)->for_keyword_loc, buffer);
620
- serialize_location(parser, &((yp_for_node_t *)node)->in_keyword_loc, buffer);
700
+ yp_serialize_location(parser, &((yp_for_node_t *)node)->for_keyword_loc, buffer);
701
+ yp_serialize_location(parser, &((yp_for_node_t *)node)->in_keyword_loc, buffer);
621
702
  if (((yp_for_node_t *)node)->do_keyword_loc.start == NULL) {
622
703
  yp_buffer_append_u8(buffer, 0);
623
704
  } else {
624
705
  yp_buffer_append_u8(buffer, 1);
625
- serialize_location(parser, &((yp_for_node_t *)node)->do_keyword_loc, buffer);
706
+ yp_serialize_location(parser, &((yp_for_node_t *)node)->do_keyword_loc, buffer);
626
707
  }
627
- serialize_location(parser, &((yp_for_node_t *)node)->end_keyword_loc, buffer);
708
+ yp_serialize_location(parser, &((yp_for_node_t *)node)->end_keyword_loc, buffer);
628
709
  break;
629
710
  }
630
711
  case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
@@ -641,32 +722,45 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
641
722
  }
642
723
  break;
643
724
  }
725
+ case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
726
+ yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->name_loc, buffer);
727
+ yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->operator_loc, buffer);
728
+ yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value, buffer);
729
+ break;
730
+ }
731
+ case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
732
+ yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->name_loc, buffer);
733
+ yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->operator_loc, buffer);
734
+ yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, buffer);
735
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->operator));
736
+ break;
737
+ }
738
+ case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
739
+ yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->name_loc, buffer);
740
+ yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->operator_loc, buffer);
741
+ yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value, buffer);
742
+ break;
743
+ }
644
744
  case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
645
745
  break;
646
746
  }
747
+ case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
748
+ break;
749
+ }
647
750
  case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
648
- serialize_location(parser, &((yp_global_variable_write_node_t *)node)->name_loc, buffer);
649
- if (((yp_global_variable_write_node_t *)node)->operator_loc.start == NULL) {
650
- yp_buffer_append_u8(buffer, 0);
651
- } else {
652
- yp_buffer_append_u8(buffer, 1);
653
- serialize_location(parser, &((yp_global_variable_write_node_t *)node)->operator_loc, buffer);
654
- }
655
- if (((yp_global_variable_write_node_t *)node)->value == NULL) {
656
- yp_buffer_append_u8(buffer, 0);
657
- } else {
658
- yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value, buffer);
659
- }
751
+ yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->name_loc, buffer);
752
+ yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value, buffer);
753
+ yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->operator_loc, buffer);
660
754
  break;
661
755
  }
662
756
  case YP_NODE_HASH_NODE: {
663
- serialize_location(parser, &((yp_hash_node_t *)node)->opening_loc, buffer);
757
+ yp_serialize_location(parser, &((yp_hash_node_t *)node)->opening_loc, buffer);
664
758
  uint32_t elements_size = yp_sizet_to_u32(((yp_hash_node_t *)node)->elements.size);
665
759
  yp_buffer_append_u32(buffer, elements_size);
666
760
  for (uint32_t index = 0; index < elements_size; index++) {
667
761
  yp_serialize_node(parser, (yp_node_t *) ((yp_hash_node_t *)node)->elements.nodes[index], buffer);
668
762
  }
669
- serialize_location(parser, &((yp_hash_node_t *)node)->closing_loc, buffer);
763
+ yp_serialize_location(parser, &((yp_hash_node_t *)node)->closing_loc, buffer);
670
764
  break;
671
765
  }
672
766
  case YP_NODE_HASH_PATTERN_NODE: {
@@ -689,13 +783,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
689
783
  yp_buffer_append_u8(buffer, 0);
690
784
  } else {
691
785
  yp_buffer_append_u8(buffer, 1);
692
- serialize_location(parser, &((yp_hash_pattern_node_t *)node)->opening_loc, buffer);
786
+ yp_serialize_location(parser, &((yp_hash_pattern_node_t *)node)->opening_loc, buffer);
693
787
  }
694
788
  if (((yp_hash_pattern_node_t *)node)->closing_loc.start == NULL) {
695
789
  yp_buffer_append_u8(buffer, 0);
696
790
  } else {
697
791
  yp_buffer_append_u8(buffer, 1);
698
- serialize_location(parser, &((yp_hash_pattern_node_t *)node)->closing_loc, buffer);
792
+ yp_serialize_location(parser, &((yp_hash_pattern_node_t *)node)->closing_loc, buffer);
699
793
  }
700
794
  break;
701
795
  }
@@ -704,7 +798,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
704
798
  yp_buffer_append_u8(buffer, 0);
705
799
  } else {
706
800
  yp_buffer_append_u8(buffer, 1);
707
- serialize_location(parser, &((yp_if_node_t *)node)->if_keyword_loc, buffer);
801
+ yp_serialize_location(parser, &((yp_if_node_t *)node)->if_keyword_loc, buffer);
708
802
  }
709
803
  yp_serialize_node(parser, (yp_node_t *)((yp_if_node_t *)node)->predicate, buffer);
710
804
  if (((yp_if_node_t *)node)->statements == NULL) {
@@ -721,7 +815,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
721
815
  yp_buffer_append_u8(buffer, 0);
722
816
  } else {
723
817
  yp_buffer_append_u8(buffer, 1);
724
- serialize_location(parser, &((yp_if_node_t *)node)->end_keyword_loc, buffer);
818
+ yp_serialize_location(parser, &((yp_if_node_t *)node)->end_keyword_loc, buffer);
725
819
  }
726
820
  break;
727
821
  }
@@ -736,44 +830,63 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
736
830
  } else {
737
831
  yp_serialize_node(parser, (yp_node_t *)((yp_in_node_t *)node)->statements, buffer);
738
832
  }
739
- serialize_location(parser, &((yp_in_node_t *)node)->in_loc, buffer);
833
+ yp_serialize_location(parser, &((yp_in_node_t *)node)->in_loc, buffer);
740
834
  if (((yp_in_node_t *)node)->then_loc.start == NULL) {
741
835
  yp_buffer_append_u8(buffer, 0);
742
836
  } else {
743
837
  yp_buffer_append_u8(buffer, 1);
744
- serialize_location(parser, &((yp_in_node_t *)node)->then_loc, buffer);
838
+ yp_serialize_location(parser, &((yp_in_node_t *)node)->then_loc, buffer);
745
839
  }
746
840
  break;
747
841
  }
842
+ case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
843
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_and_write_node_t *)node)->name));
844
+ yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->name_loc, buffer);
845
+ yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
846
+ yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value, buffer);
847
+ break;
848
+ }
849
+ case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
850
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->name));
851
+ yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
852
+ yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->operator_loc, buffer);
853
+ yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value, buffer);
854
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->operator));
855
+ break;
856
+ }
857
+ case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
858
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_or_write_node_t *)node)->name));
859
+ yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->name_loc, buffer);
860
+ yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
861
+ yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value, buffer);
862
+ break;
863
+ }
748
864
  case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
865
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_read_node_t *)node)->name));
866
+ break;
867
+ }
868
+ case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
869
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_target_node_t *)node)->name));
749
870
  break;
750
871
  }
751
872
  case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
752
- serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->name_loc, buffer);
753
- if (((yp_instance_variable_write_node_t *)node)->value == NULL) {
754
- yp_buffer_append_u8(buffer, 0);
755
- } else {
756
- yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, buffer);
757
- }
758
- if (((yp_instance_variable_write_node_t *)node)->operator_loc.start == NULL) {
759
- yp_buffer_append_u8(buffer, 0);
760
- } else {
761
- yp_buffer_append_u8(buffer, 1);
762
- serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->operator_loc, buffer);
763
- }
873
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_write_node_t *)node)->name));
874
+ yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->name_loc, buffer);
875
+ yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, buffer);
876
+ yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->operator_loc, buffer);
764
877
  break;
765
878
  }
766
879
  case YP_NODE_INTEGER_NODE: {
767
880
  break;
768
881
  }
769
882
  case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
770
- serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
883
+ yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
771
884
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_regular_expression_node_t *)node)->parts.size);
772
885
  yp_buffer_append_u32(buffer, parts_size);
773
886
  for (uint32_t index = 0; index < parts_size; index++) {
774
887
  yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
775
888
  }
776
- serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
889
+ yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
777
890
  yp_buffer_append_u32(buffer, node->flags >> 1);
778
891
  break;
779
892
  }
@@ -782,7 +895,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
782
895
  yp_buffer_append_u8(buffer, 0);
783
896
  } else {
784
897
  yp_buffer_append_u8(buffer, 1);
785
- serialize_location(parser, &((yp_interpolated_string_node_t *)node)->opening_loc, buffer);
898
+ yp_serialize_location(parser, &((yp_interpolated_string_node_t *)node)->opening_loc, buffer);
786
899
  }
787
900
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_string_node_t *)node)->parts.size);
788
901
  yp_buffer_append_u32(buffer, parts_size);
@@ -793,7 +906,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
793
906
  yp_buffer_append_u8(buffer, 0);
794
907
  } else {
795
908
  yp_buffer_append_u8(buffer, 1);
796
- serialize_location(parser, &((yp_interpolated_string_node_t *)node)->closing_loc, buffer);
909
+ yp_serialize_location(parser, &((yp_interpolated_string_node_t *)node)->closing_loc, buffer);
797
910
  }
798
911
  break;
799
912
  }
@@ -802,7 +915,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
802
915
  yp_buffer_append_u8(buffer, 0);
803
916
  } else {
804
917
  yp_buffer_append_u8(buffer, 1);
805
- serialize_location(parser, &((yp_interpolated_symbol_node_t *)node)->opening_loc, buffer);
918
+ yp_serialize_location(parser, &((yp_interpolated_symbol_node_t *)node)->opening_loc, buffer);
806
919
  }
807
920
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_symbol_node_t *)node)->parts.size);
808
921
  yp_buffer_append_u32(buffer, parts_size);
@@ -813,18 +926,18 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
813
926
  yp_buffer_append_u8(buffer, 0);
814
927
  } else {
815
928
  yp_buffer_append_u8(buffer, 1);
816
- serialize_location(parser, &((yp_interpolated_symbol_node_t *)node)->closing_loc, buffer);
929
+ yp_serialize_location(parser, &((yp_interpolated_symbol_node_t *)node)->closing_loc, buffer);
817
930
  }
818
931
  break;
819
932
  }
820
933
  case YP_NODE_INTERPOLATED_X_STRING_NODE: {
821
- serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->opening_loc, buffer);
934
+ yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->opening_loc, buffer);
822
935
  uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_x_string_node_t *)node)->parts.size);
823
936
  yp_buffer_append_u32(buffer, parts_size);
824
937
  for (uint32_t index = 0; index < parts_size; index++) {
825
938
  yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_x_string_node_t *)node)->parts.nodes[index], buffer);
826
939
  }
827
- serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->closing_loc, buffer);
940
+ yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->closing_loc, buffer);
828
941
  break;
829
942
  }
830
943
  case YP_NODE_KEYWORD_HASH_NODE: {
@@ -836,7 +949,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
836
949
  break;
837
950
  }
838
951
  case YP_NODE_KEYWORD_PARAMETER_NODE: {
839
- serialize_location(parser, &((yp_keyword_parameter_node_t *)node)->name_loc, buffer);
952
+ yp_serialize_location(parser, &((yp_keyword_parameter_node_t *)node)->name_loc, buffer);
840
953
  if (((yp_keyword_parameter_node_t *)node)->value == NULL) {
841
954
  yp_buffer_append_u8(buffer, 0);
842
955
  } else {
@@ -845,12 +958,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
845
958
  break;
846
959
  }
847
960
  case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
848
- serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
961
+ yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
849
962
  if (((yp_keyword_rest_parameter_node_t *)node)->name_loc.start == NULL) {
850
963
  yp_buffer_append_u8(buffer, 0);
851
964
  } else {
852
965
  yp_buffer_append_u8(buffer, 1);
853
- serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
966
+ yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
854
967
  }
855
968
  break;
856
969
  }
@@ -860,7 +973,9 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
860
973
  for (uint32_t index = 0; index < locals_size; index++) {
861
974
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_lambda_node_t *)node)->locals.ids[index]));
862
975
  }
863
- serialize_location(parser, &((yp_lambda_node_t *)node)->opening_loc, buffer);
976
+ yp_serialize_location(parser, &((yp_lambda_node_t *)node)->operator_loc, buffer);
977
+ yp_serialize_location(parser, &((yp_lambda_node_t *)node)->opening_loc, buffer);
978
+ yp_serialize_location(parser, &((yp_lambda_node_t *)node)->closing_loc, buffer);
864
979
  if (((yp_lambda_node_t *)node)->parameters == NULL) {
865
980
  yp_buffer_append_u8(buffer, 0);
866
981
  } else {
@@ -873,38 +988,59 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
873
988
  }
874
989
  break;
875
990
  }
991
+ case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
992
+ yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->name_loc, buffer);
993
+ yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->operator_loc, buffer);
994
+ yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value, buffer);
995
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_and_write_node_t *)node)->name));
996
+ yp_buffer_append_u32(buffer, ((yp_local_variable_and_write_node_t *)node)->depth);
997
+ break;
998
+ }
999
+ case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1000
+ yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->name_loc, buffer);
1001
+ yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->operator_loc, buffer);
1002
+ yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, buffer);
1003
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_write_node_t *)node)->name));
1004
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_write_node_t *)node)->operator));
1005
+ yp_buffer_append_u32(buffer, ((yp_local_variable_operator_write_node_t *)node)->depth);
1006
+ break;
1007
+ }
1008
+ case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
1009
+ yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->name_loc, buffer);
1010
+ yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->operator_loc, buffer);
1011
+ yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value, buffer);
1012
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_or_write_node_t *)node)->name));
1013
+ yp_buffer_append_u32(buffer, ((yp_local_variable_or_write_node_t *)node)->depth);
1014
+ break;
1015
+ }
876
1016
  case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
877
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_read_node_t *)node)->constant_id));
1017
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_read_node_t *)node)->name));
878
1018
  yp_buffer_append_u32(buffer, ((yp_local_variable_read_node_t *)node)->depth);
879
1019
  break;
880
1020
  }
1021
+ case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
1022
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_target_node_t *)node)->name));
1023
+ yp_buffer_append_u32(buffer, ((yp_local_variable_target_node_t *)node)->depth);
1024
+ break;
1025
+ }
881
1026
  case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
882
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_write_node_t *)node)->constant_id));
1027
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_write_node_t *)node)->name));
883
1028
  yp_buffer_append_u32(buffer, ((yp_local_variable_write_node_t *)node)->depth);
884
- if (((yp_local_variable_write_node_t *)node)->value == NULL) {
885
- yp_buffer_append_u8(buffer, 0);
886
- } else {
887
- yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_write_node_t *)node)->value, buffer);
888
- }
889
- serialize_location(parser, &((yp_local_variable_write_node_t *)node)->name_loc, buffer);
890
- if (((yp_local_variable_write_node_t *)node)->operator_loc.start == NULL) {
891
- yp_buffer_append_u8(buffer, 0);
892
- } else {
893
- yp_buffer_append_u8(buffer, 1);
894
- serialize_location(parser, &((yp_local_variable_write_node_t *)node)->operator_loc, buffer);
895
- }
1029
+ yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->name_loc, buffer);
1030
+ yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_write_node_t *)node)->value, buffer);
1031
+ yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->operator_loc, buffer);
896
1032
  break;
897
1033
  }
898
1034
  case YP_NODE_MATCH_PREDICATE_NODE: {
899
1035
  yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->value, buffer);
900
1036
  yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, buffer);
901
- serialize_location(parser, &((yp_match_predicate_node_t *)node)->operator_loc, buffer);
1037
+ yp_serialize_location(parser, &((yp_match_predicate_node_t *)node)->operator_loc, buffer);
902
1038
  break;
903
1039
  }
904
1040
  case YP_NODE_MATCH_REQUIRED_NODE: {
905
1041
  yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->value, buffer);
906
1042
  yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->pattern, buffer);
907
- serialize_location(parser, &((yp_match_required_node_t *)node)->operator_loc, buffer);
1043
+ yp_serialize_location(parser, &((yp_match_required_node_t *)node)->operator_loc, buffer);
908
1044
  break;
909
1045
  }
910
1046
  case YP_NODE_MISSING_NODE: {
@@ -916,14 +1052,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
916
1052
  for (uint32_t index = 0; index < locals_size; index++) {
917
1053
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_module_node_t *)node)->locals.ids[index]));
918
1054
  }
919
- serialize_location(parser, &((yp_module_node_t *)node)->module_keyword_loc, buffer);
1055
+ yp_serialize_location(parser, &((yp_module_node_t *)node)->module_keyword_loc, buffer);
920
1056
  yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->constant_path, buffer);
921
1057
  if (((yp_module_node_t *)node)->body == NULL) {
922
1058
  yp_buffer_append_u8(buffer, 0);
923
1059
  } else {
924
1060
  yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->body, buffer);
925
1061
  }
926
- serialize_location(parser, &((yp_module_node_t *)node)->end_keyword_loc, buffer);
1062
+ 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);
927
1064
  break;
928
1065
  }
929
1066
  case YP_NODE_MULTI_WRITE_NODE: {
@@ -936,7 +1073,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
936
1073
  yp_buffer_append_u8(buffer, 0);
937
1074
  } else {
938
1075
  yp_buffer_append_u8(buffer, 1);
939
- serialize_location(parser, &((yp_multi_write_node_t *)node)->operator_loc, buffer);
1076
+ yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->operator_loc, buffer);
940
1077
  }
941
1078
  if (((yp_multi_write_node_t *)node)->value == NULL) {
942
1079
  yp_buffer_append_u8(buffer, 0);
@@ -947,13 +1084,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
947
1084
  yp_buffer_append_u8(buffer, 0);
948
1085
  } else {
949
1086
  yp_buffer_append_u8(buffer, 1);
950
- serialize_location(parser, &((yp_multi_write_node_t *)node)->lparen_loc, buffer);
1087
+ yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->lparen_loc, buffer);
951
1088
  }
952
1089
  if (((yp_multi_write_node_t *)node)->rparen_loc.start == NULL) {
953
1090
  yp_buffer_append_u8(buffer, 0);
954
1091
  } else {
955
1092
  yp_buffer_append_u8(buffer, 1);
956
- serialize_location(parser, &((yp_multi_write_node_t *)node)->rparen_loc, buffer);
1093
+ yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->rparen_loc, buffer);
957
1094
  }
958
1095
  break;
959
1096
  }
@@ -963,44 +1100,32 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
963
1100
  } else {
964
1101
  yp_serialize_node(parser, (yp_node_t *)((yp_next_node_t *)node)->arguments, buffer);
965
1102
  }
966
- serialize_location(parser, &((yp_next_node_t *)node)->keyword_loc, buffer);
1103
+ yp_serialize_location(parser, &((yp_next_node_t *)node)->keyword_loc, buffer);
967
1104
  break;
968
1105
  }
969
1106
  case YP_NODE_NIL_NODE: {
970
1107
  break;
971
1108
  }
972
1109
  case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
973
- serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
974
- serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
1110
+ yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
1111
+ yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
975
1112
  break;
976
1113
  }
977
1114
  case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
978
- break;
979
- }
980
- case YP_NODE_OPERATOR_WRITE_NODE: {
981
- yp_serialize_node(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->target, buffer);
982
- serialize_location(parser, &((yp_operator_write_node_t *)node)->operator_loc, buffer);
983
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_operator_write_node_t *)node)->operator));
984
- yp_serialize_node(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->value, buffer);
1115
+ yp_buffer_append_u32(buffer, ((yp_numbered_reference_read_node_t *)node)->number);
985
1116
  break;
986
1117
  }
987
1118
  case YP_NODE_OPTIONAL_PARAMETER_NODE: {
988
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_optional_parameter_node_t *)node)->constant_id));
989
- serialize_location(parser, &((yp_optional_parameter_node_t *)node)->name_loc, buffer);
990
- serialize_location(parser, &((yp_optional_parameter_node_t *)node)->operator_loc, buffer);
1119
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_optional_parameter_node_t *)node)->name));
1120
+ yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->name_loc, buffer);
1121
+ yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->operator_loc, buffer);
991
1122
  yp_serialize_node(parser, (yp_node_t *)((yp_optional_parameter_node_t *)node)->value, buffer);
992
1123
  break;
993
1124
  }
994
1125
  case YP_NODE_OR_NODE: {
995
1126
  yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->left, buffer);
996
1127
  yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->right, buffer);
997
- serialize_location(parser, &((yp_or_node_t *)node)->operator_loc, buffer);
998
- break;
999
- }
1000
- case YP_NODE_OR_WRITE_NODE: {
1001
- yp_serialize_node(parser, (yp_node_t *)((yp_or_write_node_t *)node)->target, buffer);
1002
- yp_serialize_node(parser, (yp_node_t *)((yp_or_write_node_t *)node)->value, buffer);
1003
- serialize_location(parser, &((yp_or_write_node_t *)node)->operator_loc, buffer);
1128
+ yp_serialize_location(parser, &((yp_or_node_t *)node)->operator_loc, buffer);
1004
1129
  break;
1005
1130
  }
1006
1131
  case YP_NODE_PARAMETERS_NODE: {
@@ -1047,20 +1172,20 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1047
1172
  } else {
1048
1173
  yp_serialize_node(parser, (yp_node_t *)((yp_parentheses_node_t *)node)->body, buffer);
1049
1174
  }
1050
- serialize_location(parser, &((yp_parentheses_node_t *)node)->opening_loc, buffer);
1051
- serialize_location(parser, &((yp_parentheses_node_t *)node)->closing_loc, buffer);
1175
+ yp_serialize_location(parser, &((yp_parentheses_node_t *)node)->opening_loc, buffer);
1176
+ yp_serialize_location(parser, &((yp_parentheses_node_t *)node)->closing_loc, buffer);
1052
1177
  break;
1053
1178
  }
1054
1179
  case YP_NODE_PINNED_EXPRESSION_NODE: {
1055
1180
  yp_serialize_node(parser, (yp_node_t *)((yp_pinned_expression_node_t *)node)->expression, buffer);
1056
- serialize_location(parser, &((yp_pinned_expression_node_t *)node)->operator_loc, buffer);
1057
- serialize_location(parser, &((yp_pinned_expression_node_t *)node)->lparen_loc, buffer);
1058
- serialize_location(parser, &((yp_pinned_expression_node_t *)node)->rparen_loc, buffer);
1181
+ yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->operator_loc, buffer);
1182
+ yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->lparen_loc, buffer);
1183
+ yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->rparen_loc, buffer);
1059
1184
  break;
1060
1185
  }
1061
1186
  case YP_NODE_PINNED_VARIABLE_NODE: {
1062
1187
  yp_serialize_node(parser, (yp_node_t *)((yp_pinned_variable_node_t *)node)->variable, buffer);
1063
- serialize_location(parser, &((yp_pinned_variable_node_t *)node)->operator_loc, buffer);
1188
+ yp_serialize_location(parser, &((yp_pinned_variable_node_t *)node)->operator_loc, buffer);
1064
1189
  break;
1065
1190
  }
1066
1191
  case YP_NODE_POST_EXECUTION_NODE: {
@@ -1069,9 +1194,9 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1069
1194
  } else {
1070
1195
  yp_serialize_node(parser, (yp_node_t *)((yp_post_execution_node_t *)node)->statements, buffer);
1071
1196
  }
1072
- serialize_location(parser, &((yp_post_execution_node_t *)node)->keyword_loc, buffer);
1073
- serialize_location(parser, &((yp_post_execution_node_t *)node)->opening_loc, buffer);
1074
- serialize_location(parser, &((yp_post_execution_node_t *)node)->closing_loc, buffer);
1197
+ yp_serialize_location(parser, &((yp_post_execution_node_t *)node)->keyword_loc, buffer);
1198
+ yp_serialize_location(parser, &((yp_post_execution_node_t *)node)->opening_loc, buffer);
1199
+ yp_serialize_location(parser, &((yp_post_execution_node_t *)node)->closing_loc, buffer);
1075
1200
  break;
1076
1201
  }
1077
1202
  case YP_NODE_PRE_EXECUTION_NODE: {
@@ -1080,9 +1205,9 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1080
1205
  } else {
1081
1206
  yp_serialize_node(parser, (yp_node_t *)((yp_pre_execution_node_t *)node)->statements, buffer);
1082
1207
  }
1083
- serialize_location(parser, &((yp_pre_execution_node_t *)node)->keyword_loc, buffer);
1084
- serialize_location(parser, &((yp_pre_execution_node_t *)node)->opening_loc, buffer);
1085
- serialize_location(parser, &((yp_pre_execution_node_t *)node)->closing_loc, buffer);
1208
+ yp_serialize_location(parser, &((yp_pre_execution_node_t *)node)->keyword_loc, buffer);
1209
+ yp_serialize_location(parser, &((yp_pre_execution_node_t *)node)->opening_loc, buffer);
1210
+ yp_serialize_location(parser, &((yp_pre_execution_node_t *)node)->closing_loc, buffer);
1086
1211
  break;
1087
1212
  }
1088
1213
  case YP_NODE_PROGRAM_NODE: {
@@ -1105,7 +1230,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1105
1230
  } else {
1106
1231
  yp_serialize_node(parser, (yp_node_t *)((yp_range_node_t *)node)->right, buffer);
1107
1232
  }
1108
- serialize_location(parser, &((yp_range_node_t *)node)->operator_loc, buffer);
1233
+ yp_serialize_location(parser, &((yp_range_node_t *)node)->operator_loc, buffer);
1109
1234
  yp_buffer_append_u32(buffer, node->flags >> 1);
1110
1235
  break;
1111
1236
  }
@@ -1117,12 +1242,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1117
1242
  break;
1118
1243
  }
1119
1244
  case YP_NODE_REGULAR_EXPRESSION_NODE: {
1120
- serialize_location(parser, &((yp_regular_expression_node_t *)node)->opening_loc, buffer);
1121
- serialize_location(parser, &((yp_regular_expression_node_t *)node)->content_loc, buffer);
1122
- serialize_location(parser, &((yp_regular_expression_node_t *)node)->closing_loc, buffer);
1123
- uint32_t unescaped_length = yp_sizet_to_u32(yp_string_length(&((yp_regular_expression_node_t *)node)->unescaped));
1124
- yp_buffer_append_u32(buffer, unescaped_length);
1125
- yp_buffer_append_str(buffer, yp_string_source(&((yp_regular_expression_node_t *)node)->unescaped), unescaped_length);
1245
+ yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->opening_loc, buffer);
1246
+ yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->content_loc, buffer);
1247
+ yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->closing_loc, buffer);
1248
+ yp_serialize_string(parser, &((yp_regular_expression_node_t *)node)->unescaped, buffer);
1126
1249
  yp_buffer_append_u32(buffer, node->flags >> 1);
1127
1250
  break;
1128
1251
  }
@@ -1132,22 +1255,22 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1132
1255
  for (uint32_t index = 0; index < parameters_size; index++) {
1133
1256
  yp_serialize_node(parser, (yp_node_t *) ((yp_required_destructured_parameter_node_t *)node)->parameters.nodes[index], buffer);
1134
1257
  }
1135
- serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->opening_loc, buffer);
1136
- serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->closing_loc, buffer);
1258
+ yp_serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->opening_loc, buffer);
1259
+ yp_serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->closing_loc, buffer);
1137
1260
  break;
1138
1261
  }
1139
1262
  case YP_NODE_REQUIRED_PARAMETER_NODE: {
1140
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_required_parameter_node_t *)node)->constant_id));
1263
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_required_parameter_node_t *)node)->name));
1141
1264
  break;
1142
1265
  }
1143
1266
  case YP_NODE_RESCUE_MODIFIER_NODE: {
1144
1267
  yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression, buffer);
1145
- serialize_location(parser, &((yp_rescue_modifier_node_t *)node)->keyword_loc, buffer);
1268
+ yp_serialize_location(parser, &((yp_rescue_modifier_node_t *)node)->keyword_loc, buffer);
1146
1269
  yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression, buffer);
1147
1270
  break;
1148
1271
  }
1149
1272
  case YP_NODE_RESCUE_NODE: {
1150
- serialize_location(parser, &((yp_rescue_node_t *)node)->keyword_loc, buffer);
1273
+ yp_serialize_location(parser, &((yp_rescue_node_t *)node)->keyword_loc, buffer);
1151
1274
  uint32_t exceptions_size = yp_sizet_to_u32(((yp_rescue_node_t *)node)->exceptions.size);
1152
1275
  yp_buffer_append_u32(buffer, exceptions_size);
1153
1276
  for (uint32_t index = 0; index < exceptions_size; index++) {
@@ -1157,7 +1280,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1157
1280
  yp_buffer_append_u8(buffer, 0);
1158
1281
  } else {
1159
1282
  yp_buffer_append_u8(buffer, 1);
1160
- serialize_location(parser, &((yp_rescue_node_t *)node)->operator_loc, buffer);
1283
+ yp_serialize_location(parser, &((yp_rescue_node_t *)node)->operator_loc, buffer);
1161
1284
  }
1162
1285
  if (((yp_rescue_node_t *)node)->reference == NULL) {
1163
1286
  yp_buffer_append_u8(buffer, 0);
@@ -1177,12 +1300,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1177
1300
  break;
1178
1301
  }
1179
1302
  case YP_NODE_REST_PARAMETER_NODE: {
1180
- serialize_location(parser, &((yp_rest_parameter_node_t *)node)->operator_loc, buffer);
1303
+ yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->operator_loc, buffer);
1181
1304
  if (((yp_rest_parameter_node_t *)node)->name_loc.start == NULL) {
1182
1305
  yp_buffer_append_u8(buffer, 0);
1183
1306
  } else {
1184
1307
  yp_buffer_append_u8(buffer, 1);
1185
- serialize_location(parser, &((yp_rest_parameter_node_t *)node)->name_loc, buffer);
1308
+ yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->name_loc, buffer);
1186
1309
  }
1187
1310
  break;
1188
1311
  }
@@ -1190,7 +1313,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1190
1313
  break;
1191
1314
  }
1192
1315
  case YP_NODE_RETURN_NODE: {
1193
- serialize_location(parser, &((yp_return_node_t *)node)->keyword_loc, buffer);
1316
+ yp_serialize_location(parser, &((yp_return_node_t *)node)->keyword_loc, buffer);
1194
1317
  if (((yp_return_node_t *)node)->arguments == NULL) {
1195
1318
  yp_buffer_append_u8(buffer, 0);
1196
1319
  } else {
@@ -1207,31 +1330,29 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1207
1330
  for (uint32_t index = 0; index < locals_size; index++) {
1208
1331
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_singleton_class_node_t *)node)->locals.ids[index]));
1209
1332
  }
1210
- serialize_location(parser, &((yp_singleton_class_node_t *)node)->class_keyword_loc, buffer);
1211
- serialize_location(parser, &((yp_singleton_class_node_t *)node)->operator_loc, buffer);
1333
+ yp_serialize_location(parser, &((yp_singleton_class_node_t *)node)->class_keyword_loc, buffer);
1334
+ yp_serialize_location(parser, &((yp_singleton_class_node_t *)node)->operator_loc, buffer);
1212
1335
  yp_serialize_node(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->expression, buffer);
1213
1336
  if (((yp_singleton_class_node_t *)node)->body == NULL) {
1214
1337
  yp_buffer_append_u8(buffer, 0);
1215
1338
  } else {
1216
1339
  yp_serialize_node(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->body, buffer);
1217
1340
  }
1218
- serialize_location(parser, &((yp_singleton_class_node_t *)node)->end_keyword_loc, buffer);
1341
+ yp_serialize_location(parser, &((yp_singleton_class_node_t *)node)->end_keyword_loc, buffer);
1219
1342
  break;
1220
1343
  }
1221
1344
  case YP_NODE_SOURCE_ENCODING_NODE: {
1222
1345
  break;
1223
1346
  }
1224
1347
  case YP_NODE_SOURCE_FILE_NODE: {
1225
- uint32_t filepath_length = yp_sizet_to_u32(yp_string_length(&((yp_source_file_node_t *)node)->filepath));
1226
- yp_buffer_append_u32(buffer, filepath_length);
1227
- yp_buffer_append_str(buffer, yp_string_source(&((yp_source_file_node_t *)node)->filepath), filepath_length);
1348
+ yp_serialize_string(parser, &((yp_source_file_node_t *)node)->filepath, buffer);
1228
1349
  break;
1229
1350
  }
1230
1351
  case YP_NODE_SOURCE_LINE_NODE: {
1231
1352
  break;
1232
1353
  }
1233
1354
  case YP_NODE_SPLAT_NODE: {
1234
- serialize_location(parser, &((yp_splat_node_t *)node)->operator_loc, buffer);
1355
+ yp_serialize_location(parser, &((yp_splat_node_t *)node)->operator_loc, buffer);
1235
1356
  if (((yp_splat_node_t *)node)->expression == NULL) {
1236
1357
  yp_buffer_append_u8(buffer, 0);
1237
1358
  } else {
@@ -1257,27 +1378,25 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1257
1378
  yp_buffer_append_u8(buffer, 0);
1258
1379
  } else {
1259
1380
  yp_buffer_append_u8(buffer, 1);
1260
- serialize_location(parser, &((yp_string_node_t *)node)->opening_loc, buffer);
1381
+ yp_serialize_location(parser, &((yp_string_node_t *)node)->opening_loc, buffer);
1261
1382
  }
1262
- serialize_location(parser, &((yp_string_node_t *)node)->content_loc, buffer);
1383
+ yp_serialize_location(parser, &((yp_string_node_t *)node)->content_loc, buffer);
1263
1384
  if (((yp_string_node_t *)node)->closing_loc.start == NULL) {
1264
1385
  yp_buffer_append_u8(buffer, 0);
1265
1386
  } else {
1266
1387
  yp_buffer_append_u8(buffer, 1);
1267
- serialize_location(parser, &((yp_string_node_t *)node)->closing_loc, buffer);
1388
+ yp_serialize_location(parser, &((yp_string_node_t *)node)->closing_loc, buffer);
1268
1389
  }
1269
- uint32_t unescaped_length = yp_sizet_to_u32(yp_string_length(&((yp_string_node_t *)node)->unescaped));
1270
- yp_buffer_append_u32(buffer, unescaped_length);
1271
- yp_buffer_append_str(buffer, yp_string_source(&((yp_string_node_t *)node)->unescaped), unescaped_length);
1390
+ yp_serialize_string(parser, &((yp_string_node_t *)node)->unescaped, buffer);
1272
1391
  break;
1273
1392
  }
1274
1393
  case YP_NODE_SUPER_NODE: {
1275
- serialize_location(parser, &((yp_super_node_t *)node)->keyword_loc, buffer);
1394
+ yp_serialize_location(parser, &((yp_super_node_t *)node)->keyword_loc, buffer);
1276
1395
  if (((yp_super_node_t *)node)->lparen_loc.start == NULL) {
1277
1396
  yp_buffer_append_u8(buffer, 0);
1278
1397
  } else {
1279
1398
  yp_buffer_append_u8(buffer, 1);
1280
- serialize_location(parser, &((yp_super_node_t *)node)->lparen_loc, buffer);
1399
+ yp_serialize_location(parser, &((yp_super_node_t *)node)->lparen_loc, buffer);
1281
1400
  }
1282
1401
  if (((yp_super_node_t *)node)->arguments == NULL) {
1283
1402
  yp_buffer_append_u8(buffer, 0);
@@ -1288,7 +1407,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1288
1407
  yp_buffer_append_u8(buffer, 0);
1289
1408
  } else {
1290
1409
  yp_buffer_append_u8(buffer, 1);
1291
- serialize_location(parser, &((yp_super_node_t *)node)->rparen_loc, buffer);
1410
+ yp_serialize_location(parser, &((yp_super_node_t *)node)->rparen_loc, buffer);
1292
1411
  }
1293
1412
  if (((yp_super_node_t *)node)->block == NULL) {
1294
1413
  yp_buffer_append_u8(buffer, 0);
@@ -1302,18 +1421,21 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1302
1421
  yp_buffer_append_u8(buffer, 0);
1303
1422
  } else {
1304
1423
  yp_buffer_append_u8(buffer, 1);
1305
- serialize_location(parser, &((yp_symbol_node_t *)node)->opening_loc, buffer);
1424
+ yp_serialize_location(parser, &((yp_symbol_node_t *)node)->opening_loc, buffer);
1425
+ }
1426
+ if (((yp_symbol_node_t *)node)->value_loc.start == NULL) {
1427
+ yp_buffer_append_u8(buffer, 0);
1428
+ } else {
1429
+ yp_buffer_append_u8(buffer, 1);
1430
+ yp_serialize_location(parser, &((yp_symbol_node_t *)node)->value_loc, buffer);
1306
1431
  }
1307
- serialize_location(parser, &((yp_symbol_node_t *)node)->value_loc, buffer);
1308
1432
  if (((yp_symbol_node_t *)node)->closing_loc.start == NULL) {
1309
1433
  yp_buffer_append_u8(buffer, 0);
1310
1434
  } else {
1311
1435
  yp_buffer_append_u8(buffer, 1);
1312
- serialize_location(parser, &((yp_symbol_node_t *)node)->closing_loc, buffer);
1436
+ yp_serialize_location(parser, &((yp_symbol_node_t *)node)->closing_loc, buffer);
1313
1437
  }
1314
- uint32_t unescaped_length = yp_sizet_to_u32(yp_string_length(&((yp_symbol_node_t *)node)->unescaped));
1315
- yp_buffer_append_u32(buffer, unescaped_length);
1316
- yp_buffer_append_str(buffer, yp_string_source(&((yp_symbol_node_t *)node)->unescaped), unescaped_length);
1438
+ yp_serialize_string(parser, &((yp_symbol_node_t *)node)->unescaped, buffer);
1317
1439
  break;
1318
1440
  }
1319
1441
  case YP_NODE_TRUE_NODE: {
@@ -1325,11 +1447,11 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1325
1447
  for (uint32_t index = 0; index < names_size; index++) {
1326
1448
  yp_serialize_node(parser, (yp_node_t *) ((yp_undef_node_t *)node)->names.nodes[index], buffer);
1327
1449
  }
1328
- serialize_location(parser, &((yp_undef_node_t *)node)->keyword_loc, buffer);
1450
+ yp_serialize_location(parser, &((yp_undef_node_t *)node)->keyword_loc, buffer);
1329
1451
  break;
1330
1452
  }
1331
1453
  case YP_NODE_UNLESS_NODE: {
1332
- serialize_location(parser, &((yp_unless_node_t *)node)->keyword_loc, buffer);
1454
+ yp_serialize_location(parser, &((yp_unless_node_t *)node)->keyword_loc, buffer);
1333
1455
  yp_serialize_node(parser, (yp_node_t *)((yp_unless_node_t *)node)->predicate, buffer);
1334
1456
  if (((yp_unless_node_t *)node)->statements == NULL) {
1335
1457
  yp_buffer_append_u8(buffer, 0);
@@ -1345,12 +1467,18 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1345
1467
  yp_buffer_append_u8(buffer, 0);
1346
1468
  } else {
1347
1469
  yp_buffer_append_u8(buffer, 1);
1348
- serialize_location(parser, &((yp_unless_node_t *)node)->end_keyword_loc, buffer);
1470
+ yp_serialize_location(parser, &((yp_unless_node_t *)node)->end_keyword_loc, buffer);
1349
1471
  }
1350
1472
  break;
1351
1473
  }
1352
1474
  case YP_NODE_UNTIL_NODE: {
1353
- serialize_location(parser, &((yp_until_node_t *)node)->keyword_loc, buffer);
1475
+ yp_serialize_location(parser, &((yp_until_node_t *)node)->keyword_loc, buffer);
1476
+ if (((yp_until_node_t *)node)->closing_loc.start == NULL) {
1477
+ yp_buffer_append_u8(buffer, 0);
1478
+ } else {
1479
+ yp_buffer_append_u8(buffer, 1);
1480
+ yp_serialize_location(parser, &((yp_until_node_t *)node)->closing_loc, buffer);
1481
+ }
1354
1482
  yp_serialize_node(parser, (yp_node_t *)((yp_until_node_t *)node)->predicate, buffer);
1355
1483
  if (((yp_until_node_t *)node)->statements == NULL) {
1356
1484
  yp_buffer_append_u8(buffer, 0);
@@ -1361,7 +1489,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1361
1489
  break;
1362
1490
  }
1363
1491
  case YP_NODE_WHEN_NODE: {
1364
- serialize_location(parser, &((yp_when_node_t *)node)->keyword_loc, buffer);
1492
+ yp_serialize_location(parser, &((yp_when_node_t *)node)->keyword_loc, buffer);
1365
1493
  uint32_t conditions_size = yp_sizet_to_u32(((yp_when_node_t *)node)->conditions.size);
1366
1494
  yp_buffer_append_u32(buffer, conditions_size);
1367
1495
  for (uint32_t index = 0; index < conditions_size; index++) {
@@ -1375,7 +1503,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1375
1503
  break;
1376
1504
  }
1377
1505
  case YP_NODE_WHILE_NODE: {
1378
- serialize_location(parser, &((yp_while_node_t *)node)->keyword_loc, buffer);
1506
+ yp_serialize_location(parser, &((yp_while_node_t *)node)->keyword_loc, buffer);
1507
+ if (((yp_while_node_t *)node)->closing_loc.start == NULL) {
1508
+ yp_buffer_append_u8(buffer, 0);
1509
+ } else {
1510
+ yp_buffer_append_u8(buffer, 1);
1511
+ yp_serialize_location(parser, &((yp_while_node_t *)node)->closing_loc, buffer);
1512
+ }
1379
1513
  yp_serialize_node(parser, (yp_node_t *)((yp_while_node_t *)node)->predicate, buffer);
1380
1514
  if (((yp_while_node_t *)node)->statements == NULL) {
1381
1515
  yp_buffer_append_u8(buffer, 0);
@@ -1386,21 +1520,19 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1386
1520
  break;
1387
1521
  }
1388
1522
  case YP_NODE_X_STRING_NODE: {
1389
- serialize_location(parser, &((yp_x_string_node_t *)node)->opening_loc, buffer);
1390
- serialize_location(parser, &((yp_x_string_node_t *)node)->content_loc, buffer);
1391
- serialize_location(parser, &((yp_x_string_node_t *)node)->closing_loc, buffer);
1392
- uint32_t unescaped_length = yp_sizet_to_u32(yp_string_length(&((yp_x_string_node_t *)node)->unescaped));
1393
- yp_buffer_append_u32(buffer, unescaped_length);
1394
- yp_buffer_append_str(buffer, yp_string_source(&((yp_x_string_node_t *)node)->unescaped), unescaped_length);
1523
+ yp_serialize_location(parser, &((yp_x_string_node_t *)node)->opening_loc, buffer);
1524
+ yp_serialize_location(parser, &((yp_x_string_node_t *)node)->content_loc, buffer);
1525
+ yp_serialize_location(parser, &((yp_x_string_node_t *)node)->closing_loc, buffer);
1526
+ yp_serialize_string(parser, &((yp_x_string_node_t *)node)->unescaped, buffer);
1395
1527
  break;
1396
1528
  }
1397
1529
  case YP_NODE_YIELD_NODE: {
1398
- serialize_location(parser, &((yp_yield_node_t *)node)->keyword_loc, buffer);
1530
+ yp_serialize_location(parser, &((yp_yield_node_t *)node)->keyword_loc, buffer);
1399
1531
  if (((yp_yield_node_t *)node)->lparen_loc.start == NULL) {
1400
1532
  yp_buffer_append_u8(buffer, 0);
1401
1533
  } else {
1402
1534
  yp_buffer_append_u8(buffer, 1);
1403
- serialize_location(parser, &((yp_yield_node_t *)node)->lparen_loc, buffer);
1535
+ yp_serialize_location(parser, &((yp_yield_node_t *)node)->lparen_loc, buffer);
1404
1536
  }
1405
1537
  if (((yp_yield_node_t *)node)->arguments == NULL) {
1406
1538
  yp_buffer_append_u8(buffer, 0);
@@ -1411,14 +1543,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1411
1543
  yp_buffer_append_u8(buffer, 0);
1412
1544
  } else {
1413
1545
  yp_buffer_append_u8(buffer, 1);
1414
- serialize_location(parser, &((yp_yield_node_t *)node)->rparen_loc, buffer);
1546
+ yp_serialize_location(parser, &((yp_yield_node_t *)node)->rparen_loc, buffer);
1415
1547
  }
1416
1548
  break;
1417
1549
  }
1418
1550
  }
1419
1551
  }
1420
1552
 
1421
- void yp_serialize_comment(yp_parser_t *parser, yp_comment_t *comment, yp_buffer_t *buffer) {
1553
+ static void
1554
+ yp_serialize_comment(yp_parser_t *parser, yp_comment_t *comment, yp_buffer_t *buffer) {
1422
1555
  // serialize type
1423
1556
  yp_buffer_append_u8(buffer, (uint8_t) comment->type);
1424
1557
 
@@ -1427,16 +1560,18 @@ void yp_serialize_comment(yp_parser_t *parser, yp_comment_t *comment, yp_buffer_
1427
1560
  yp_buffer_append_u32(buffer, yp_ptrdifft_to_u32(comment->end - comment->start));
1428
1561
  }
1429
1562
 
1430
- void yp_serialize_comment_list(yp_parser_t *parser, yp_list_t list, yp_buffer_t *buffer) {
1431
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(&list)));
1563
+ static void
1564
+ yp_serialize_comment_list(yp_parser_t *parser, yp_list_t *list, yp_buffer_t *buffer) {
1565
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(list)));
1432
1566
 
1433
1567
  yp_comment_t *comment;
1434
- for (comment = (yp_comment_t *) list.head; comment != NULL; comment = (yp_comment_t *) comment->node.next) {
1568
+ for (comment = (yp_comment_t *) list->head; comment != NULL; comment = (yp_comment_t *) comment->node.next) {
1435
1569
  yp_serialize_comment(parser, comment, buffer);
1436
1570
  }
1437
1571
  }
1438
1572
 
1439
- void yp_serialize_diagnostic(yp_parser_t *parser, yp_diagnostic_t *diagnostic, yp_buffer_t *buffer) {
1573
+ static void
1574
+ yp_serialize_diagnostic(yp_parser_t *parser, yp_diagnostic_t *diagnostic, yp_buffer_t *buffer) {
1440
1575
  // serialize message
1441
1576
  size_t message_length = strlen(diagnostic->message);
1442
1577
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(message_length));
@@ -1447,31 +1582,30 @@ void yp_serialize_diagnostic(yp_parser_t *parser, yp_diagnostic_t *diagnostic, y
1447
1582
  yp_buffer_append_u32(buffer, yp_ptrdifft_to_u32(diagnostic->end - diagnostic->start));
1448
1583
  }
1449
1584
 
1450
- void yp_serialize_diagnostic_list(yp_parser_t *parser, yp_list_t list, yp_buffer_t *buffer) {
1451
- yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(&list)));
1585
+ static void
1586
+ yp_serialize_diagnostic_list(yp_parser_t *parser, yp_list_t *list, yp_buffer_t *buffer) {
1587
+ yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(list)));
1452
1588
 
1453
1589
  yp_diagnostic_t *diagnostic;
1454
- for (diagnostic = (yp_diagnostic_t *) list.head; diagnostic != NULL; diagnostic = (yp_diagnostic_t *) diagnostic->node.next) {
1590
+ for (diagnostic = (yp_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (yp_diagnostic_t *) diagnostic->node.next) {
1455
1591
  yp_serialize_diagnostic(parser, diagnostic, buffer);
1456
1592
  }
1457
1593
  }
1458
1594
 
1459
- #line 145 "serialize.c.erb"
1460
- void
1461
- yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1462
- // First, serialize the encoding of the parser.
1463
- size_t encoding_length = strlen(parser->encoding.name);
1595
+ static void
1596
+ yp_serialize_encoding(yp_encoding_t *encoding, yp_buffer_t *buffer) {
1597
+ size_t encoding_length = strlen(encoding->name);
1464
1598
  yp_buffer_append_u32(buffer, yp_sizet_to_u32(encoding_length));
1465
- yp_buffer_append_str(buffer, parser->encoding.name, encoding_length);
1466
-
1467
- // Serialize the comments
1468
- yp_serialize_comment_list(parser, parser->comment_list, buffer);
1469
-
1470
- // Serialize the errors
1471
- yp_serialize_diagnostic_list(parser, parser->error_list, buffer);
1599
+ yp_buffer_append_str(buffer, encoding->name, encoding_length);
1600
+ }
1472
1601
 
1473
- // Serialize the warnings
1474
- yp_serialize_diagnostic_list(parser, parser->warning_list, buffer);
1602
+ #line 181 "serialize.c.erb"
1603
+ void
1604
+ yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
1605
+ yp_serialize_encoding(&parser->encoding, buffer);
1606
+ yp_serialize_comment_list(parser, &parser->comment_list, buffer);
1607
+ yp_serialize_diagnostic_list(parser, &parser->error_list, buffer);
1608
+ yp_serialize_diagnostic_list(parser, &parser->warning_list, buffer);
1475
1609
 
1476
1610
  // Here we're going to leave space for the offset of the constant pool in
1477
1611
  // the buffer.
@@ -1522,7 +1656,7 @@ serialize_token(void *data, yp_parser_t *parser, yp_token_t *token) {
1522
1656
  }
1523
1657
 
1524
1658
  YP_EXPORTED_FUNCTION void
1525
- yp_lex_serialize(const char *source, size_t size, const char *filepath, yp_buffer_t *buffer) {
1659
+ yp_lex_serialize(const uint8_t *source, size_t size, const char *filepath, yp_buffer_t *buffer) {
1526
1660
  yp_parser_t parser;
1527
1661
  yp_parser_init(&parser, source, size, filepath);
1528
1662
 
@@ -1535,16 +1669,35 @@ yp_lex_serialize(const char *source, size_t size, const char *filepath, yp_buffe
1535
1669
  yp_node_t *node = yp_parse(&parser);
1536
1670
 
1537
1671
  // Append 0 to mark end of tokens
1538
- yp_buffer_append_u32(buffer, 0);
1672
+ yp_buffer_append_u8(buffer, 0);
1539
1673
 
1540
- // Serialize the comments
1541
- yp_serialize_comment_list(&parser, parser.comment_list, buffer);
1674
+ yp_serialize_encoding(&parser.encoding, buffer);
1675
+ yp_serialize_comment_list(&parser, &parser.comment_list, buffer);
1676
+ yp_serialize_diagnostic_list(&parser, &parser.error_list, buffer);
1677
+ yp_serialize_diagnostic_list(&parser, &parser.warning_list, buffer);
1542
1678
 
1543
- // Serialize the errors
1544
- yp_serialize_diagnostic_list(&parser, parser.error_list, buffer);
1679
+ yp_node_destroy(&parser, node);
1680
+ yp_parser_free(&parser);
1681
+ }
1682
+
1683
+ // Parse and serialize both the AST and the tokens represented by the given
1684
+ // source to the given buffer.
1685
+ YP_EXPORTED_FUNCTION void
1686
+ yp_parse_lex_serialize(const uint8_t *source, size_t size, yp_buffer_t *buffer, const char *metadata) {
1687
+ yp_parser_t parser;
1688
+ yp_parser_init(&parser, source, size, NULL);
1689
+ if (metadata) yp_parser_metadata(&parser, metadata);
1690
+
1691
+ yp_lex_callback_t lex_callback = (yp_lex_callback_t) {
1692
+ .data = (void *) buffer,
1693
+ .callback = serialize_token,
1694
+ };
1695
+
1696
+ parser.lex_callback = &lex_callback;
1697
+ yp_node_t *node = yp_parse(&parser);
1545
1698
 
1546
- // Serialize the warnings
1547
- yp_serialize_diagnostic_list(&parser, parser.warning_list, buffer);
1699
+ yp_buffer_append_u8(buffer, 0);
1700
+ yp_serialize(&parser, node, buffer);
1548
1701
 
1549
1702
  yp_node_destroy(&parser, node);
1550
1703
  yp_parser_free(&parser);