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/prettyprint.c CHANGED
@@ -231,6 +231,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
231
231
  pm_buffer_concat(output_buffer, prefix_buffer);
232
232
  pm_buffer_append_string(output_buffer, "+-- flags:", 10);
233
233
  bool found = false;
234
+ if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS) {
235
+ if (found) pm_buffer_append_byte(output_buffer, ',');
236
+ pm_buffer_append_string(output_buffer, " contains_keywords", 18);
237
+ found = true;
238
+ }
234
239
  if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT) {
235
240
  if (found) pm_buffer_append_byte(output_buffer, ',');
236
241
  pm_buffer_append_string(output_buffer, " contains_keyword_splat", 23);
@@ -1367,20 +1372,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
1367
1372
  pm_buffer_append_byte(output_buffer, '\n');
1368
1373
  }
1369
1374
 
1370
- // operator
1375
+ // binary_operator
1371
1376
  {
1372
1377
  pm_buffer_concat(output_buffer, prefix_buffer);
1373
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
1378
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
1374
1379
  pm_buffer_append_byte(output_buffer, ' ');
1375
- prettyprint_constant(output_buffer, parser, cast->operator);
1380
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
1376
1381
  pm_buffer_append_byte(output_buffer, '\n');
1377
1382
  }
1378
1383
 
1379
- // operator_loc
1384
+ // binary_operator_loc
1380
1385
  {
1381
1386
  pm_buffer_concat(output_buffer, prefix_buffer);
1382
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
1383
- pm_location_t *location = &cast->operator_loc;
1387
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
1388
+ pm_location_t *location = &cast->binary_operator_loc;
1384
1389
  pm_buffer_append_byte(output_buffer, ' ');
1385
1390
  prettyprint_location(output_buffer, parser, location);
1386
1391
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2026,11 +2031,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2026
2031
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2027
2032
  }
2028
2033
 
2029
- // operator_loc
2034
+ // binary_operator_loc
2030
2035
  {
2031
2036
  pm_buffer_concat(output_buffer, prefix_buffer);
2032
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2033
- pm_location_t *location = &cast->operator_loc;
2037
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2038
+ pm_location_t *location = &cast->binary_operator_loc;
2034
2039
  pm_buffer_append_byte(output_buffer, ' ');
2035
2040
  prettyprint_location(output_buffer, parser, location);
2036
2041
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2051,12 +2056,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2051
2056
  prefix_buffer->length = prefix_length;
2052
2057
  }
2053
2058
 
2054
- // operator
2059
+ // binary_operator
2055
2060
  {
2056
2061
  pm_buffer_concat(output_buffer, prefix_buffer);
2057
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2062
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2058
2063
  pm_buffer_append_byte(output_buffer, ' ');
2059
- prettyprint_constant(output_buffer, parser, cast->operator);
2064
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2060
2065
  pm_buffer_append_byte(output_buffer, '\n');
2061
2066
  }
2062
2067
 
@@ -2285,11 +2290,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2285
2290
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2286
2291
  }
2287
2292
 
2288
- // operator_loc
2293
+ // binary_operator_loc
2289
2294
  {
2290
2295
  pm_buffer_concat(output_buffer, prefix_buffer);
2291
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2292
- pm_location_t *location = &cast->operator_loc;
2296
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2297
+ pm_location_t *location = &cast->binary_operator_loc;
2293
2298
  pm_buffer_append_byte(output_buffer, ' ');
2294
2299
  prettyprint_location(output_buffer, parser, location);
2295
2300
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2310,12 +2315,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2310
2315
  prefix_buffer->length = prefix_length;
2311
2316
  }
2312
2317
 
2313
- // operator
2318
+ // binary_operator
2314
2319
  {
2315
2320
  pm_buffer_concat(output_buffer, prefix_buffer);
2316
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2321
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2317
2322
  pm_buffer_append_byte(output_buffer, ' ');
2318
- prettyprint_constant(output_buffer, parser, cast->operator);
2323
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2319
2324
  pm_buffer_append_byte(output_buffer, '\n');
2320
2325
  }
2321
2326
 
@@ -2444,17 +2449,17 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2444
2449
  }
2445
2450
  }
2446
2451
 
2447
- // child
2452
+ // name
2448
2453
  {
2449
2454
  pm_buffer_concat(output_buffer, prefix_buffer);
2450
- pm_buffer_append_string(output_buffer, "+-- child:", 10);
2451
- pm_buffer_append_byte(output_buffer, '\n');
2452
-
2453
- size_t prefix_length = prefix_buffer->length;
2454
- pm_buffer_append_string(prefix_buffer, "| ", 4);
2455
- pm_buffer_concat(output_buffer, prefix_buffer);
2456
- prettyprint_node(output_buffer, parser, (pm_node_t *) cast->child, prefix_buffer);
2457
- prefix_buffer->length = prefix_length;
2455
+ pm_buffer_append_string(output_buffer, "+-- name:", 9);
2456
+ if (cast->name == 0) {
2457
+ pm_buffer_append_string(output_buffer, " nil\n", 5);
2458
+ } else {
2459
+ pm_buffer_append_byte(output_buffer, ' ');
2460
+ prettyprint_constant(output_buffer, parser, cast->name);
2461
+ pm_buffer_append_byte(output_buffer, '\n');
2462
+ }
2458
2463
  }
2459
2464
 
2460
2465
  // delimiter_loc
@@ -2469,6 +2474,18 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2469
2474
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2470
2475
  }
2471
2476
 
2477
+ // name_loc
2478
+ {
2479
+ pm_buffer_concat(output_buffer, prefix_buffer);
2480
+ pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2481
+ pm_location_t *location = &cast->name_loc;
2482
+ pm_buffer_append_byte(output_buffer, ' ');
2483
+ prettyprint_location(output_buffer, parser, location);
2484
+ pm_buffer_append_string(output_buffer, " = \"", 4);
2485
+ pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
2486
+ pm_buffer_append_string(output_buffer, "\"\n", 2);
2487
+ }
2488
+
2472
2489
  break;
2473
2490
  }
2474
2491
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
@@ -2490,11 +2507,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2490
2507
  prefix_buffer->length = prefix_length;
2491
2508
  }
2492
2509
 
2493
- // operator_loc
2510
+ // binary_operator_loc
2494
2511
  {
2495
2512
  pm_buffer_concat(output_buffer, prefix_buffer);
2496
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2497
- pm_location_t *location = &cast->operator_loc;
2513
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2514
+ pm_location_t *location = &cast->binary_operator_loc;
2498
2515
  pm_buffer_append_byte(output_buffer, ' ');
2499
2516
  prettyprint_location(output_buffer, parser, location);
2500
2517
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2515,12 +2532,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2515
2532
  prefix_buffer->length = prefix_length;
2516
2533
  }
2517
2534
 
2518
- // operator
2535
+ // binary_operator
2519
2536
  {
2520
2537
  pm_buffer_concat(output_buffer, prefix_buffer);
2521
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2538
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2522
2539
  pm_buffer_append_byte(output_buffer, ' ');
2523
- prettyprint_constant(output_buffer, parser, cast->operator);
2540
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2524
2541
  pm_buffer_append_byte(output_buffer, '\n');
2525
2542
  }
2526
2543
 
@@ -2595,17 +2612,17 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2595
2612
  }
2596
2613
  }
2597
2614
 
2598
- // child
2615
+ // name
2599
2616
  {
2600
2617
  pm_buffer_concat(output_buffer, prefix_buffer);
2601
- pm_buffer_append_string(output_buffer, "+-- child:", 10);
2602
- pm_buffer_append_byte(output_buffer, '\n');
2603
-
2604
- size_t prefix_length = prefix_buffer->length;
2605
- pm_buffer_append_string(prefix_buffer, "| ", 4);
2606
- pm_buffer_concat(output_buffer, prefix_buffer);
2607
- prettyprint_node(output_buffer, parser, (pm_node_t *) cast->child, prefix_buffer);
2608
- prefix_buffer->length = prefix_length;
2618
+ pm_buffer_append_string(output_buffer, "+-- name:", 9);
2619
+ if (cast->name == 0) {
2620
+ pm_buffer_append_string(output_buffer, " nil\n", 5);
2621
+ } else {
2622
+ pm_buffer_append_byte(output_buffer, ' ');
2623
+ prettyprint_constant(output_buffer, parser, cast->name);
2624
+ pm_buffer_append_byte(output_buffer, '\n');
2625
+ }
2609
2626
  }
2610
2627
 
2611
2628
  // delimiter_loc
@@ -2620,6 +2637,18 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2620
2637
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2621
2638
  }
2622
2639
 
2640
+ // name_loc
2641
+ {
2642
+ pm_buffer_concat(output_buffer, prefix_buffer);
2643
+ pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2644
+ pm_location_t *location = &cast->name_loc;
2645
+ pm_buffer_append_byte(output_buffer, ' ');
2646
+ prettyprint_location(output_buffer, parser, location);
2647
+ pm_buffer_append_string(output_buffer, " = \"", 4);
2648
+ pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
2649
+ pm_buffer_append_string(output_buffer, "\"\n", 2);
2650
+ }
2651
+
2623
2652
  break;
2624
2653
  }
2625
2654
  case PM_CONSTANT_PATH_WRITE_NODE: {
@@ -3603,11 +3632,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
3603
3632
  pm_buffer_append_string(output_buffer, "\"\n", 2);
3604
3633
  }
3605
3634
 
3606
- // operator_loc
3635
+ // binary_operator_loc
3607
3636
  {
3608
3637
  pm_buffer_concat(output_buffer, prefix_buffer);
3609
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3610
- pm_location_t *location = &cast->operator_loc;
3638
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
3639
+ pm_location_t *location = &cast->binary_operator_loc;
3611
3640
  pm_buffer_append_byte(output_buffer, ' ');
3612
3641
  prettyprint_location(output_buffer, parser, location);
3613
3642
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -3628,12 +3657,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
3628
3657
  prefix_buffer->length = prefix_length;
3629
3658
  }
3630
3659
 
3631
- // operator
3660
+ // binary_operator
3632
3661
  {
3633
3662
  pm_buffer_concat(output_buffer, prefix_buffer);
3634
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
3663
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
3635
3664
  pm_buffer_append_byte(output_buffer, ' ');
3636
- prettyprint_constant(output_buffer, parser, cast->operator);
3665
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
3637
3666
  pm_buffer_append_byte(output_buffer, '\n');
3638
3667
  }
3639
3668
 
@@ -4420,20 +4449,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4420
4449
  }
4421
4450
  }
4422
4451
 
4423
- // operator
4452
+ // binary_operator
4424
4453
  {
4425
4454
  pm_buffer_concat(output_buffer, prefix_buffer);
4426
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
4455
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4427
4456
  pm_buffer_append_byte(output_buffer, ' ');
4428
- prettyprint_constant(output_buffer, parser, cast->operator);
4457
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
4429
4458
  pm_buffer_append_byte(output_buffer, '\n');
4430
4459
  }
4431
4460
 
4432
- // operator_loc
4461
+ // binary_operator_loc
4433
4462
  {
4434
4463
  pm_buffer_concat(output_buffer, prefix_buffer);
4435
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4436
- pm_location_t *location = &cast->operator_loc;
4464
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4465
+ pm_location_t *location = &cast->binary_operator_loc;
4437
4466
  pm_buffer_append_byte(output_buffer, ' ');
4438
4467
  prettyprint_location(output_buffer, parser, location);
4439
4468
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -4798,11 +4827,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4798
4827
  pm_buffer_append_string(output_buffer, "\"\n", 2);
4799
4828
  }
4800
4829
 
4801
- // operator_loc
4830
+ // binary_operator_loc
4802
4831
  {
4803
4832
  pm_buffer_concat(output_buffer, prefix_buffer);
4804
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4805
- pm_location_t *location = &cast->operator_loc;
4833
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4834
+ pm_location_t *location = &cast->binary_operator_loc;
4806
4835
  pm_buffer_append_byte(output_buffer, ' ');
4807
4836
  prettyprint_location(output_buffer, parser, location);
4808
4837
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -4823,12 +4852,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4823
4852
  prefix_buffer->length = prefix_length;
4824
4853
  }
4825
4854
 
4826
- // operator
4855
+ // binary_operator
4827
4856
  {
4828
4857
  pm_buffer_concat(output_buffer, prefix_buffer);
4829
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
4858
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4830
4859
  pm_buffer_append_byte(output_buffer, ' ');
4831
- prettyprint_constant(output_buffer, parser, cast->operator);
4860
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
4832
4861
  pm_buffer_append_byte(output_buffer, '\n');
4833
4862
  }
4834
4863
 
@@ -5715,11 +5744,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
5715
5744
  pm_buffer_append_string(output_buffer, "\"\n", 2);
5716
5745
  }
5717
5746
 
5718
- // operator_loc
5747
+ // binary_operator_loc
5719
5748
  {
5720
5749
  pm_buffer_concat(output_buffer, prefix_buffer);
5721
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5722
- pm_location_t *location = &cast->operator_loc;
5750
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
5751
+ pm_location_t *location = &cast->binary_operator_loc;
5723
5752
  pm_buffer_append_byte(output_buffer, ' ');
5724
5753
  prettyprint_location(output_buffer, parser, location);
5725
5754
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -5749,12 +5778,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
5749
5778
  pm_buffer_append_byte(output_buffer, '\n');
5750
5779
  }
5751
5780
 
5752
- // operator
5781
+ // binary_operator
5753
5782
  {
5754
5783
  pm_buffer_concat(output_buffer, prefix_buffer);
5755
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
5784
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
5756
5785
  pm_buffer_append_byte(output_buffer, ' ');
5757
- prettyprint_constant(output_buffer, parser, cast->operator);
5786
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
5758
5787
  pm_buffer_append_byte(output_buffer, '\n');
5759
5788
  }
5760
5789
 
@@ -7701,6 +7730,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
7701
7730
  prettyprint_location(output_buffer, parser, &node->location);
7702
7731
  pm_buffer_append_string(output_buffer, ")\n", 2);
7703
7732
 
7733
+ // flags
7734
+ {
7735
+ pm_buffer_concat(output_buffer, prefix_buffer);
7736
+ pm_buffer_append_string(output_buffer, "+-- flags:", 10);
7737
+ bool found = false;
7738
+ if (cast->base.flags & PM_RETURN_NODE_FLAGS_REDUNDANT) {
7739
+ if (found) pm_buffer_append_byte(output_buffer, ',');
7740
+ pm_buffer_append_string(output_buffer, " redundant", 10);
7741
+ found = true;
7742
+ }
7743
+ if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7744
+ pm_buffer_append_byte(output_buffer, '\n');
7745
+ }
7746
+
7704
7747
  // keyword_loc
7705
7748
  {
7706
7749
  pm_buffer_concat(output_buffer, prefix_buffer);