prism 0.27.0 → 0.29.0

Sign up to get free protection for your applications and to get access to all the features.
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