prism 0.27.0 → 0.29.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 (65) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +45 -1
  3. data/config.yml +68 -44
  4. data/docs/configuration.md +1 -0
  5. data/ext/prism/api_node.c +854 -847
  6. data/ext/prism/extconf.rb +27 -23
  7. data/ext/prism/extension.c +5 -3
  8. data/ext/prism/extension.h +1 -1
  9. data/include/prism/ast.h +70 -48
  10. data/include/prism/diagnostic.h +23 -6
  11. data/include/prism/options.h +2 -2
  12. data/include/prism/parser.h +10 -0
  13. data/include/prism/static_literals.h +8 -6
  14. data/include/prism/version.h +2 -2
  15. data/lib/prism/desugar_compiler.rb +4 -4
  16. data/lib/prism/dot_visitor.rb +54 -38
  17. data/lib/prism/dsl.rb +24 -24
  18. data/lib/prism/ffi.rb +4 -4
  19. data/lib/prism/inspect_visitor.rb +2156 -0
  20. data/lib/prism/lex_compat.rb +1 -1
  21. data/lib/prism/mutation_compiler.rb +2 -2
  22. data/lib/prism/node.rb +737 -1863
  23. data/lib/prism/node_ext.rb +176 -5
  24. data/lib/prism/parse_result/comments.rb +1 -1
  25. data/lib/prism/parse_result/newlines.rb +1 -1
  26. data/lib/prism/parse_result.rb +78 -0
  27. data/lib/prism/pattern.rb +12 -6
  28. data/lib/prism/polyfill/byteindex.rb +13 -0
  29. data/lib/prism/polyfill/unpack1.rb +14 -0
  30. data/lib/prism/reflection.rb +20 -20
  31. data/lib/prism/serialize.rb +32 -15
  32. data/lib/prism/translation/parser/compiler.rb +156 -26
  33. data/lib/prism/translation/parser.rb +7 -7
  34. data/lib/prism/translation/ripper.rb +29 -25
  35. data/lib/prism/translation/ruby_parser.rb +13 -13
  36. data/lib/prism.rb +2 -1
  37. data/prism.gemspec +37 -38
  38. data/rbi/prism/compiler.rbi +3 -5
  39. data/rbi/prism/inspect_visitor.rbi +12 -0
  40. data/rbi/prism/node.rbi +405 -370
  41. data/rbi/prism/node_ext.rbi +5 -0
  42. data/rbi/prism/parse_result.rbi +23 -0
  43. data/rbi/prism/translation/ripper.rbi +1 -11
  44. data/sig/prism/dsl.rbs +12 -12
  45. data/sig/prism/inspect_visitor.rbs +22 -0
  46. data/sig/prism/lex_compat.rbs +10 -0
  47. data/sig/prism/node.rbs +108 -91
  48. data/sig/prism/node_ext.rbs +4 -0
  49. data/sig/prism/parse_result.rbs +12 -0
  50. data/src/diagnostic.c +66 -33
  51. data/src/node.c +89 -64
  52. data/src/options.c +2 -2
  53. data/src/prettyprint.c +109 -66
  54. data/src/prism.c +862 -317
  55. data/src/serialize.c +21 -18
  56. data/src/static_literals.c +120 -34
  57. data/src/token_type.c +6 -6
  58. metadata +8 -9
  59. data/lib/prism/node_inspector.rb +0 -68
  60. data/lib/prism/polyfill/string.rb +0 -12
  61. data/rbi/prism/desugar_compiler.rbi +0 -5
  62. data/rbi/prism/mutation_compiler.rbi +0 -5
  63. data/rbi/prism/translation/parser/compiler.rbi +0 -13
  64. data/rbi/prism/translation/ripper/ripper_compiler.rbi +0 -5
  65. data/rbi/prism/translation/ruby_parser.rbi +0 -11
data/src/node.c CHANGED
@@ -414,7 +414,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
414
414
  if (cast->parent != NULL) {
415
415
  pm_node_destroy(parser, (pm_node_t *)cast->parent);
416
416
  }
417
- pm_node_destroy(parser, (pm_node_t *)cast->child);
418
417
  break;
419
418
  }
420
419
  #line 123 "node.c.erb"
@@ -437,7 +436,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
437
436
  if (cast->parent != NULL) {
438
437
  pm_node_destroy(parser, (pm_node_t *)cast->parent);
439
438
  }
440
- pm_node_destroy(parser, (pm_node_t *)cast->child);
441
439
  break;
442
440
  }
443
441
  #line 123 "node.c.erb"
@@ -1558,7 +1556,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1558
1556
  if (cast->parent != NULL) {
1559
1557
  pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
1560
1558
  }
1561
- pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1562
1559
  break;
1563
1560
  }
1564
1561
  #line 170 "node.c.erb"
@@ -1584,7 +1581,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1584
1581
  if (cast->parent != NULL) {
1585
1582
  pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
1586
1583
  }
1587
- pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1588
1584
  break;
1589
1585
  }
1590
1586
  #line 170 "node.c.erb"
@@ -3255,9 +3251,6 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
3255
3251
  pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
3256
3252
  }
3257
3253
 
3258
- // Visit the child field
3259
- pm_visit_node((const pm_node_t *) cast->child, visitor, data);
3260
-
3261
3254
  break;
3262
3255
  }
3263
3256
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
@@ -3290,9 +3283,6 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
3290
3283
  pm_visit_node((const pm_node_t *) cast->parent, visitor, data);
3291
3284
  }
3292
3285
 
3293
- // Visit the child field
3294
- pm_visit_node((const pm_node_t *) cast->child, visitor, data);
3295
-
3296
3286
  break;
3297
3287
  }
3298
3288
  case PM_CONSTANT_PATH_WRITE_NODE: {
@@ -4434,6 +4424,11 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
4434
4424
  pm_buffer_append_string(buffer, "\"flags\":", 8);
4435
4425
  size_t flags = 0;
4436
4426
  pm_buffer_append_byte(buffer, '[');
4427
+ if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
4428
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
4429
+ pm_buffer_append_string(buffer, "\"CONTAINS_KEYWORDS\"", 19);
4430
+ flags++;
4431
+ }
4437
4432
  if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT)) {
4438
4433
  if (flags != 0) pm_buffer_append_byte(buffer, ',');
4439
4434
  pm_buffer_append_string(buffer, "\"CONTAINS_KEYWORD_SPLAT\"", 24);
@@ -5174,15 +5169,15 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5174
5169
  pm_buffer_append_string(buffer, "\"write_name\":", 13);
5175
5170
  pm_dump_json_constant(buffer, parser, cast->write_name);
5176
5171
 
5177
- // Dump the operator field
5172
+ // Dump the binary_operator field
5178
5173
  pm_buffer_append_byte(buffer, ',');
5179
- pm_buffer_append_string(buffer, "\"operator\":", 11);
5180
- pm_dump_json_constant(buffer, parser, cast->operator);
5174
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
5175
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
5181
5176
 
5182
- // Dump the operator_loc field
5177
+ // Dump the binary_operator_loc field
5183
5178
  pm_buffer_append_byte(buffer, ',');
5184
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
5185
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
5179
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
5180
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
5186
5181
 
5187
5182
  // Dump the value field
5188
5183
  pm_buffer_append_byte(buffer, ',');
@@ -5566,20 +5561,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5566
5561
  pm_buffer_append_string(buffer, "\"name_loc\":", 11);
5567
5562
  pm_dump_json_location(buffer, parser, &cast->name_loc);
5568
5563
 
5569
- // Dump the operator_loc field
5564
+ // Dump the binary_operator_loc field
5570
5565
  pm_buffer_append_byte(buffer, ',');
5571
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
5572
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
5566
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
5567
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
5573
5568
 
5574
5569
  // Dump the value field
5575
5570
  pm_buffer_append_byte(buffer, ',');
5576
5571
  pm_buffer_append_string(buffer, "\"value\":", 8);
5577
5572
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
5578
5573
 
5579
- // Dump the operator field
5574
+ // Dump the binary_operator field
5580
5575
  pm_buffer_append_byte(buffer, ',');
5581
- pm_buffer_append_string(buffer, "\"operator\":", 11);
5582
- pm_dump_json_constant(buffer, parser, cast->operator);
5576
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
5577
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
5583
5578
 
5584
5579
  pm_buffer_append_byte(buffer, '}');
5585
5580
  break;
@@ -5715,20 +5710,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5715
5710
  pm_buffer_append_string(buffer, "\"name_loc\":", 11);
5716
5711
  pm_dump_json_location(buffer, parser, &cast->name_loc);
5717
5712
 
5718
- // Dump the operator_loc field
5713
+ // Dump the binary_operator_loc field
5719
5714
  pm_buffer_append_byte(buffer, ',');
5720
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
5721
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
5715
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
5716
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
5722
5717
 
5723
5718
  // Dump the value field
5724
5719
  pm_buffer_append_byte(buffer, ',');
5725
5720
  pm_buffer_append_string(buffer, "\"value\":", 8);
5726
5721
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
5727
5722
 
5728
- // Dump the operator field
5723
+ // Dump the binary_operator field
5729
5724
  pm_buffer_append_byte(buffer, ',');
5730
- pm_buffer_append_string(buffer, "\"operator\":", 11);
5731
- pm_dump_json_constant(buffer, parser, cast->operator);
5725
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
5726
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
5732
5727
 
5733
5728
  pm_buffer_append_byte(buffer, '}');
5734
5729
  break;
@@ -5801,16 +5796,25 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5801
5796
  pm_buffer_append_string(buffer, "null", 4);
5802
5797
  }
5803
5798
 
5804
- // Dump the child field
5799
+ // Dump the name field
5805
5800
  pm_buffer_append_byte(buffer, ',');
5806
- pm_buffer_append_string(buffer, "\"child\":", 8);
5807
- pm_dump_json(buffer, parser, (const pm_node_t *) cast->child);
5801
+ pm_buffer_append_string(buffer, "\"name\":", 7);
5802
+ if (cast->name != PM_CONSTANT_ID_UNSET) {
5803
+ pm_dump_json_constant(buffer, parser, cast->name);
5804
+ } else {
5805
+ pm_buffer_append_string(buffer, "null", 4);
5806
+ }
5808
5807
 
5809
5808
  // Dump the delimiter_loc field
5810
5809
  pm_buffer_append_byte(buffer, ',');
5811
5810
  pm_buffer_append_string(buffer, "\"delimiter_loc\":", 16);
5812
5811
  pm_dump_json_location(buffer, parser, &cast->delimiter_loc);
5813
5812
 
5813
+ // Dump the name_loc field
5814
+ pm_buffer_append_byte(buffer, ',');
5815
+ pm_buffer_append_string(buffer, "\"name_loc\":", 11);
5816
+ pm_dump_json_location(buffer, parser, &cast->name_loc);
5817
+
5814
5818
  pm_buffer_append_byte(buffer, '}');
5815
5819
  break;
5816
5820
  }
@@ -5825,20 +5829,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5825
5829
  pm_buffer_append_string(buffer, "\"target\":", 9);
5826
5830
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->target);
5827
5831
 
5828
- // Dump the operator_loc field
5832
+ // Dump the binary_operator_loc field
5829
5833
  pm_buffer_append_byte(buffer, ',');
5830
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
5831
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
5834
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
5835
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
5832
5836
 
5833
5837
  // Dump the value field
5834
5838
  pm_buffer_append_byte(buffer, ',');
5835
5839
  pm_buffer_append_string(buffer, "\"value\":", 8);
5836
5840
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
5837
5841
 
5838
- // Dump the operator field
5842
+ // Dump the binary_operator field
5839
5843
  pm_buffer_append_byte(buffer, ',');
5840
- pm_buffer_append_string(buffer, "\"operator\":", 11);
5841
- pm_dump_json_constant(buffer, parser, cast->operator);
5844
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
5845
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
5842
5846
 
5843
5847
  pm_buffer_append_byte(buffer, '}');
5844
5848
  break;
@@ -5882,16 +5886,25 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
5882
5886
  pm_buffer_append_string(buffer, "null", 4);
5883
5887
  }
5884
5888
 
5885
- // Dump the child field
5889
+ // Dump the name field
5886
5890
  pm_buffer_append_byte(buffer, ',');
5887
- pm_buffer_append_string(buffer, "\"child\":", 8);
5888
- pm_dump_json(buffer, parser, (const pm_node_t *) cast->child);
5891
+ pm_buffer_append_string(buffer, "\"name\":", 7);
5892
+ if (cast->name != PM_CONSTANT_ID_UNSET) {
5893
+ pm_dump_json_constant(buffer, parser, cast->name);
5894
+ } else {
5895
+ pm_buffer_append_string(buffer, "null", 4);
5896
+ }
5889
5897
 
5890
5898
  // Dump the delimiter_loc field
5891
5899
  pm_buffer_append_byte(buffer, ',');
5892
5900
  pm_buffer_append_string(buffer, "\"delimiter_loc\":", 16);
5893
5901
  pm_dump_json_location(buffer, parser, &cast->delimiter_loc);
5894
5902
 
5903
+ // Dump the name_loc field
5904
+ pm_buffer_append_byte(buffer, ',');
5905
+ pm_buffer_append_string(buffer, "\"name_loc\":", 11);
5906
+ pm_dump_json_location(buffer, parser, &cast->name_loc);
5907
+
5895
5908
  pm_buffer_append_byte(buffer, '}');
5896
5909
  break;
5897
5910
  }
@@ -6486,20 +6499,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
6486
6499
  pm_buffer_append_string(buffer, "\"name_loc\":", 11);
6487
6500
  pm_dump_json_location(buffer, parser, &cast->name_loc);
6488
6501
 
6489
- // Dump the operator_loc field
6502
+ // Dump the binary_operator_loc field
6490
6503
  pm_buffer_append_byte(buffer, ',');
6491
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
6492
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
6504
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
6505
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
6493
6506
 
6494
6507
  // Dump the value field
6495
6508
  pm_buffer_append_byte(buffer, ',');
6496
6509
  pm_buffer_append_string(buffer, "\"value\":", 8);
6497
6510
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
6498
6511
 
6499
- // Dump the operator field
6512
+ // Dump the binary_operator field
6500
6513
  pm_buffer_append_byte(buffer, ',');
6501
- pm_buffer_append_string(buffer, "\"operator\":", 11);
6502
- pm_dump_json_constant(buffer, parser, cast->operator);
6514
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
6515
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
6503
6516
 
6504
6517
  pm_buffer_append_byte(buffer, '}');
6505
6518
  break;
@@ -6982,15 +6995,15 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
6982
6995
  pm_buffer_append_string(buffer, "null", 4);
6983
6996
  }
6984
6997
 
6985
- // Dump the operator field
6998
+ // Dump the binary_operator field
6986
6999
  pm_buffer_append_byte(buffer, ',');
6987
- pm_buffer_append_string(buffer, "\"operator\":", 11);
6988
- pm_dump_json_constant(buffer, parser, cast->operator);
7000
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
7001
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
6989
7002
 
6990
- // Dump the operator_loc field
7003
+ // Dump the binary_operator_loc field
6991
7004
  pm_buffer_append_byte(buffer, ',');
6992
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
6993
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
7005
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
7006
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
6994
7007
 
6995
7008
  // Dump the value field
6996
7009
  pm_buffer_append_byte(buffer, ',');
@@ -7206,20 +7219,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
7206
7219
  pm_buffer_append_string(buffer, "\"name_loc\":", 11);
7207
7220
  pm_dump_json_location(buffer, parser, &cast->name_loc);
7208
7221
 
7209
- // Dump the operator_loc field
7222
+ // Dump the binary_operator_loc field
7210
7223
  pm_buffer_append_byte(buffer, ',');
7211
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
7212
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
7224
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
7225
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
7213
7226
 
7214
7227
  // Dump the value field
7215
7228
  pm_buffer_append_byte(buffer, ',');
7216
7229
  pm_buffer_append_string(buffer, "\"value\":", 8);
7217
7230
  pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
7218
7231
 
7219
- // Dump the operator field
7232
+ // Dump the binary_operator field
7220
7233
  pm_buffer_append_byte(buffer, ',');
7221
- pm_buffer_append_string(buffer, "\"operator\":", 11);
7222
- pm_dump_json_constant(buffer, parser, cast->operator);
7234
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
7235
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
7223
7236
 
7224
7237
  pm_buffer_append_byte(buffer, '}');
7225
7238
  break;
@@ -7848,10 +7861,10 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
7848
7861
  pm_buffer_append_string(buffer, "\"name_loc\":", 11);
7849
7862
  pm_dump_json_location(buffer, parser, &cast->name_loc);
7850
7863
 
7851
- // Dump the operator_loc field
7864
+ // Dump the binary_operator_loc field
7852
7865
  pm_buffer_append_byte(buffer, ',');
7853
- pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
7854
- pm_dump_json_location(buffer, parser, &cast->operator_loc);
7866
+ pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
7867
+ pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
7855
7868
 
7856
7869
  // Dump the value field
7857
7870
  pm_buffer_append_byte(buffer, ',');
@@ -7863,10 +7876,10 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
7863
7876
  pm_buffer_append_string(buffer, "\"name\":", 7);
7864
7877
  pm_dump_json_constant(buffer, parser, cast->name);
7865
7878
 
7866
- // Dump the operator field
7879
+ // Dump the binary_operator field
7867
7880
  pm_buffer_append_byte(buffer, ',');
7868
- pm_buffer_append_string(buffer, "\"operator\":", 11);
7869
- pm_dump_json_constant(buffer, parser, cast->operator);
7881
+ pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
7882
+ pm_dump_json_constant(buffer, parser, cast->binary_operator);
7870
7883
 
7871
7884
  // Dump the depth field
7872
7885
  pm_buffer_append_byte(buffer, ',');
@@ -9134,6 +9147,18 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
9134
9147
  const pm_return_node_t *cast = (const pm_return_node_t *) node;
9135
9148
  pm_dump_json_location(buffer, parser, &cast->base.location);
9136
9149
 
9150
+ // Dump the flags field
9151
+ pm_buffer_append_byte(buffer, ',');
9152
+ pm_buffer_append_string(buffer, "\"flags\":", 8);
9153
+ size_t flags = 0;
9154
+ pm_buffer_append_byte(buffer, '[');
9155
+ if (PM_NODE_FLAG_P(cast, PM_RETURN_NODE_FLAGS_REDUNDANT)) {
9156
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
9157
+ pm_buffer_append_string(buffer, "\"REDUNDANT\"", 11);
9158
+ flags++;
9159
+ }
9160
+ pm_buffer_append_byte(buffer, ']');
9161
+
9137
9162
  // Dump the keyword_loc field
9138
9163
  pm_buffer_append_byte(buffer, ',');
9139
9164
  pm_buffer_append_string(buffer, "\"keyword_loc\":", 14);
data/src/options.c CHANGED
@@ -58,8 +58,8 @@ pm_options_version_set(pm_options_t *options, const char *version, size_t length
58
58
  case 5:
59
59
  assert(version != NULL);
60
60
 
61
- if (strncmp(version, "3.3.0", length) == 0) {
62
- options->version = PM_OPTIONS_VERSION_CRUBY_3_3_0;
61
+ if ((strncmp(version, "3.3.0", length) == 0) || (strncmp(version, "3.3.1", length) == 0)) {
62
+ options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
63
63
  return true;
64
64
  }
65
65