ruby_parser 3.8.1 → 3.8.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (19) hide show
  1. checksums.yaml +4 -4
  2. checksums.yaml.gz.sig +0 -0
  3. data.tar.gz.sig +2 -2
  4. data/History.txt +7 -0
  5. data/lib/ruby18_parser.rb +1 -1
  6. data/lib/ruby19_parser.rb +1 -1
  7. data/lib/ruby20_parser.rb +2365 -2360
  8. data/lib/ruby20_parser.y +33 -24
  9. data/lib/ruby21_parser.rb +2480 -2478
  10. data/lib/ruby21_parser.y +33 -24
  11. data/lib/ruby22_parser.rb +2405 -2398
  12. data/lib/ruby22_parser.y +33 -24
  13. data/lib/ruby23_parser.rb +3198 -3286
  14. data/lib/ruby23_parser.y +34 -55
  15. data/lib/ruby_parser.yy +36 -69
  16. data/lib/ruby_parser_extras.rb +43 -3
  17. data/test/test_ruby_parser.rb +42 -1
  18. metadata +4 -18
  19. metadata.gz.sig +0 -0
data/lib/ruby23_parser.y CHANGED
@@ -185,13 +185,21 @@ rule
185
185
  {
186
186
  result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
187
187
  }
188
- | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
188
+ | primary_value call_op tIDENTIFIER tOP_ASGN command_call
189
189
  {
190
190
  result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
191
+ if val[1] == '&.'
192
+ result[0] = :safe_op_asgn
193
+ end
194
+ result.line = val[0].line
191
195
  }
192
- | primary_value tDOT tCONSTANT tOP_ASGN command_call
196
+ | primary_value call_op tCONSTANT tOP_ASGN command_call
193
197
  {
194
198
  result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
199
+ if val[1] == '&.'
200
+ result[0] = :safe_op_asgn
201
+ end
202
+ result.line = val[0].line
195
203
  }
196
204
  | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
197
205
  {
@@ -297,19 +305,14 @@ rule
297
305
  result.insert 1, operation
298
306
  end
299
307
  }
300
- | primary_value tDOT operation2 command_args =tLOWEST
308
+ | primary_value call_op operation2 command_args =tLOWEST
301
309
  {
302
- result = new_call val[0], val[2].to_sym, val[3]
310
+ result = new_call val[0], val[2].to_sym, val[3], val[1]
303
311
  }
304
- | primary_value tLONELY operation2 command_args =tLOWEST
305
- {
306
- result = new_call val[0], val[2].to_sym, val[3]
307
- result[0] = :safe_call
308
- }
309
- | primary_value tDOT operation2 command_args cmd_brace_block
312
+ | primary_value call_op operation2 command_args cmd_brace_block
310
313
  {
311
314
  recv, _, msg, args, block = val
312
- call = new_call recv, msg.to_sym, args
315
+ call = new_call recv, msg.to_sym, args, val[1]
313
316
 
314
317
  block_dup_check call, block
315
318
 
@@ -451,25 +454,17 @@ rule
451
454
  {
452
455
  result = self.aryset val[0], val[2]
453
456
  }
454
- | primary_value tDOT tIDENTIFIER
457
+ | primary_value call_op tIDENTIFIER
455
458
  {
456
- result = s(:attrasgn, val[0], :"#{val[2]}=")
457
- }
458
- | primary_value tLONELY tIDENTIFIER
459
- {
460
- result = s(:attrasgnx, val[0], :"#{val[2]}=")
459
+ result = new_attrasgn val[0], val[2], val[1]
461
460
  }
462
461
  | primary_value tCOLON2 tIDENTIFIER
463
462
  {
464
463
  result = s(:attrasgn, val[0], :"#{val[2]}=")
465
464
  }
466
- | primary_value tDOT tCONSTANT
465
+ | primary_value call_op tCONSTANT
467
466
  {
468
- result = s(:attrasgn, val[0], :"#{val[2]}=")
469
- }
470
- | primary_value tLONELY tCONSTANT
471
- {
472
- result = s(:attrasgnx, val[0], :"#{val[2]}=")
467
+ result = new_attrasgn val[0], val[2], val[1]
473
468
  }
474
469
  | primary_value tCOLON2 tCONSTANT
475
470
  {
@@ -507,25 +502,17 @@ rule
507
502
  {
508
503
  result = self.aryset val[0], val[2]
509
504
  }
510
- | primary_value tDOT tIDENTIFIER # REFACTOR
511
- {
512
- result = s(:attrasgn, val[0], :"#{val[2]}=")
513
- }
514
- | primary_value tLONELY tIDENTIFIER
505
+ | primary_value call_op tIDENTIFIER # REFACTOR
515
506
  {
516
- result = s(:safe_attrasgn, val[0], :"#{val[2]}=")
507
+ result = new_attrasgn val[0], val[2], val[1]
517
508
  }
518
509
  | primary_value tCOLON2 tIDENTIFIER
519
510
  {
520
511
  result = s(:attrasgn, val[0], :"#{val[2]}=")
521
512
  }
522
- | primary_value tDOT tCONSTANT # REFACTOR?
513
+ | primary_value call_op tCONSTANT # REFACTOR?
523
514
  {
524
- result = s(:attrasgn, val[0], :"#{val[2]}=")
525
- }
526
- | primary_value tLONELY tCONSTANT
527
- {
528
- result = s(:safe_attrasgn, val[0], :"#{val[2]}=")
515
+ result = new_attrasgn val[0], val[2], val[1]
529
516
  }
530
517
  | primary_value tCOLON2 tCONSTANT
531
518
  {
@@ -642,13 +629,13 @@ rule
642
629
  val[2][0] = :arglist if val[2]
643
630
  result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
644
631
  }
645
- | primary_value tDOT tIDENTIFIER tOP_ASGN arg
632
+ | primary_value call_op tIDENTIFIER tOP_ASGN arg
646
633
  {
647
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
634
+ result = new_op_asgn2 val
648
635
  }
649
- | primary_value tDOT tCONSTANT tOP_ASGN arg
636
+ | primary_value call_op tCONSTANT tOP_ASGN arg
650
637
  {
651
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
638
+ result = new_op_asgn2 val
652
639
  }
653
640
  | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
654
641
  {
@@ -1567,14 +1554,9 @@ opt_block_args_tail: tCOMMA block_args_tail
1567
1554
  args = self.call_args val[2..-1]
1568
1555
  result = val[0].concat args[1..-1]
1569
1556
  }
1570
- | primary_value tDOT operation2 opt_paren_args
1571
- {
1572
- result = new_call val[0], val[2].to_sym, val[3]
1573
- }
1574
- | primary_value tLONELY operation2 opt_paren_args
1557
+ | primary_value call_op operation2 opt_paren_args
1575
1558
  {
1576
- result = new_call val[0], val[2].to_sym, val[3]
1577
- result[0] = :safe_call
1559
+ result = new_call val[0], val[2].to_sym, val[3], val[1]
1578
1560
  }
1579
1561
  | primary_value tCOLON2 operation2 paren_args
1580
1562
  {
@@ -1584,14 +1566,9 @@ opt_block_args_tail: tCOMMA block_args_tail
1584
1566
  {
1585
1567
  result = new_call val[0], val[2].to_sym
1586
1568
  }
1587
- | primary_value tDOT paren_args
1569
+ | primary_value call_op paren_args
1588
1570
  {
1589
- result = new_call val[0], :call, val[2]
1590
- }
1591
- | primary_value tLONELY paren_args
1592
- {
1593
- result = new_call val[0], :call, val[2]
1594
- result[0] = :safe_call
1571
+ result = new_call val[0], :call, val[2], val[1]
1595
1572
  }
1596
1573
  | primary_value tCOLON2 paren_args
1597
1574
  {
@@ -1868,7 +1845,7 @@ regexp_contents: none
1868
1845
  result = lexer.lex_strterm
1869
1846
 
1870
1847
  lexer.lex_strterm = nil
1871
- lexer.lex_state = :expr_beg
1848
+ lexer.lex_state = :expr_beg # TODO: expr_value ?
1872
1849
  }
1873
1850
  string_dvar
1874
1851
  {
@@ -1889,7 +1866,7 @@ regexp_contents: none
1889
1866
  lexer.brace_nest = 0
1890
1867
  lexer.string_nest = 0
1891
1868
 
1892
- lexer.lex_state = :expr_beg
1869
+ lexer.lex_state = :expr_value
1893
1870
  }
1894
1871
  compstmt tRCURLY
1895
1872
  {
@@ -2398,6 +2375,8 @@ keyword_variable: kNIL { result = s(:nil) }
2398
2375
  operation2: tIDENTIFIER | tCONSTANT | tFID | op
2399
2376
  operation3: tIDENTIFIER | tFID | op
2400
2377
  dot_or_colon: tDOT | tCOLON2
2378
+ call_op: tDOT
2379
+ | tLONELY
2401
2380
  opt_terms: | terms
2402
2381
  opt_nl: | tNL
2403
2382
  rparen: opt_nl tRPAREN
data/lib/ruby_parser.yy CHANGED
@@ -195,13 +195,21 @@ rule
195
195
  {
196
196
  result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
197
197
  }
198
- | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
198
+ | primary_value call_op tIDENTIFIER tOP_ASGN command_call
199
199
  {
200
200
  result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
201
+ if val[1] == '&.'
202
+ result[0] = :safe_op_asgn
203
+ end
204
+ result.line = val[0].line
201
205
  }
202
- | primary_value tDOT tCONSTANT tOP_ASGN command_call
206
+ | primary_value call_op tCONSTANT tOP_ASGN command_call
203
207
  {
204
208
  result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
209
+ if val[1] == '&.'
210
+ result[0] = :safe_op_asgn
211
+ end
212
+ result.line = val[0].line
205
213
  }
206
214
  | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
207
215
  {
@@ -313,21 +321,14 @@ rule
313
321
  result.insert 1, operation
314
322
  end
315
323
  }
316
- | primary_value tDOT operation2 command_args =tLOWEST
324
+ | primary_value call_op operation2 command_args =tLOWEST
317
325
  {
318
- result = new_call val[0], val[2].to_sym, val[3]
326
+ result = new_call val[0], val[2].to_sym, val[3], val[1]
319
327
  }
320
- #if defined(RUBY23)
321
- | primary_value tLONELY operation2 command_args =tLOWEST
322
- {
323
- result = new_call val[0], val[2].to_sym, val[3]
324
- result[0] = :safe_call
325
- }
326
- #endif
327
- | primary_value tDOT operation2 command_args cmd_brace_block
328
+ | primary_value call_op operation2 command_args cmd_brace_block
328
329
  {
329
330
  recv, _, msg, args, block = val
330
- call = new_call recv, msg.to_sym, args
331
+ call = new_call recv, msg.to_sym, args, val[1]
331
332
 
332
333
  block_dup_check call, block
333
334
 
@@ -469,30 +470,18 @@ rule
469
470
  {
470
471
  result = self.aryset val[0], val[2]
471
472
  }
472
- | primary_value tDOT tIDENTIFIER
473
- {
474
- result = s(:attrasgn, val[0], :"#{val[2]}=")
475
- }
476
- #if defined(RUBY23)
477
- | primary_value tLONELY tIDENTIFIER
473
+ | primary_value call_op tIDENTIFIER
478
474
  {
479
- result = s(:attrasgnx, val[0], :"#{val[2]}=")
475
+ result = new_attrasgn val[0], val[2], val[1]
480
476
  }
481
- #endif
482
477
  | primary_value tCOLON2 tIDENTIFIER
483
478
  {
484
479
  result = s(:attrasgn, val[0], :"#{val[2]}=")
485
480
  }
486
- | primary_value tDOT tCONSTANT
481
+ | primary_value call_op tCONSTANT
487
482
  {
488
- result = s(:attrasgn, val[0], :"#{val[2]}=")
483
+ result = new_attrasgn val[0], val[2], val[1]
489
484
  }
490
- #if defined(RUBY23)
491
- | primary_value tLONELY tCONSTANT
492
- {
493
- result = s(:attrasgnx, val[0], :"#{val[2]}=")
494
- }
495
- #endif
496
485
  | primary_value tCOLON2 tCONSTANT
497
486
  {
498
487
  if (self.in_def || self.in_single > 0) then
@@ -529,30 +518,18 @@ rule
529
518
  {
530
519
  result = self.aryset val[0], val[2]
531
520
  }
532
- | primary_value tDOT tIDENTIFIER # REFACTOR
533
- {
534
- result = s(:attrasgn, val[0], :"#{val[2]}=")
535
- }
536
- #if defined(RUBY23)
537
- | primary_value tLONELY tIDENTIFIER
521
+ | primary_value call_op tIDENTIFIER # REFACTOR
538
522
  {
539
- result = s(:safe_attrasgn, val[0], :"#{val[2]}=")
523
+ result = new_attrasgn val[0], val[2], val[1]
540
524
  }
541
- #endif
542
525
  | primary_value tCOLON2 tIDENTIFIER
543
526
  {
544
527
  result = s(:attrasgn, val[0], :"#{val[2]}=")
545
528
  }
546
- | primary_value tDOT tCONSTANT # REFACTOR?
547
- {
548
- result = s(:attrasgn, val[0], :"#{val[2]}=")
549
- }
550
- #if defined(RUBY23)
551
- | primary_value tLONELY tCONSTANT
529
+ | primary_value call_op tCONSTANT # REFACTOR?
552
530
  {
553
- result = s(:safe_attrasgn, val[0], :"#{val[2]}=")
531
+ result = new_attrasgn val[0], val[2], val[1]
554
532
  }
555
- #endif
556
533
  | primary_value tCOLON2 tCONSTANT
557
534
  {
558
535
  if (self.in_def || self.in_single > 0) then
@@ -671,13 +648,13 @@ rule
671
648
  val[2][0] = :arglist if val[2]
672
649
  result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
673
650
  }
674
- | primary_value tDOT tIDENTIFIER tOP_ASGN arg
651
+ | primary_value call_op tIDENTIFIER tOP_ASGN arg
675
652
  {
676
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
653
+ result = new_op_asgn2 val
677
654
  }
678
- | primary_value tDOT tCONSTANT tOP_ASGN arg
655
+ | primary_value call_op tCONSTANT tOP_ASGN arg
679
656
  {
680
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
657
+ result = new_op_asgn2 val
681
658
  }
682
659
  | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
683
660
  {
@@ -1606,17 +1583,10 @@ opt_block_args_tail: tCOMMA block_args_tail
1606
1583
  args = self.call_args val[2..-1]
1607
1584
  result = val[0].concat args[1..-1]
1608
1585
  }
1609
- | primary_value tDOT operation2 opt_paren_args
1610
- {
1611
- result = new_call val[0], val[2].to_sym, val[3]
1612
- }
1613
- #if defined(RUBY23)
1614
- | primary_value tLONELY operation2 opt_paren_args
1586
+ | primary_value call_op operation2 opt_paren_args
1615
1587
  {
1616
- result = new_call val[0], val[2].to_sym, val[3]
1617
- result[0] = :safe_call
1588
+ result = new_call val[0], val[2].to_sym, val[3], val[1]
1618
1589
  }
1619
- #endif
1620
1590
  | primary_value tCOLON2 operation2 paren_args
1621
1591
  {
1622
1592
  result = new_call val[0], val[2].to_sym, val[3]
@@ -1625,17 +1595,10 @@ opt_block_args_tail: tCOMMA block_args_tail
1625
1595
  {
1626
1596
  result = new_call val[0], val[2].to_sym
1627
1597
  }
1628
- | primary_value tDOT paren_args
1598
+ | primary_value call_op paren_args
1629
1599
  {
1630
- result = new_call val[0], :call, val[2]
1600
+ result = new_call val[0], :call, val[2], val[1]
1631
1601
  }
1632
- #if defined(RUBY23)
1633
- | primary_value tLONELY paren_args
1634
- {
1635
- result = new_call val[0], :call, val[2]
1636
- result[0] = :safe_call
1637
- }
1638
- #endif
1639
1602
  | primary_value tCOLON2 paren_args
1640
1603
  {
1641
1604
  result = new_call val[0], :call, val[2]
@@ -1911,7 +1874,7 @@ regexp_contents: none
1911
1874
  result = lexer.lex_strterm
1912
1875
 
1913
1876
  lexer.lex_strterm = nil
1914
- lexer.lex_state = :expr_beg
1877
+ lexer.lex_state = :expr_beg # TODO: expr_value ?
1915
1878
  }
1916
1879
  string_dvar
1917
1880
  {
@@ -1932,7 +1895,7 @@ regexp_contents: none
1932
1895
  lexer.brace_nest = 0
1933
1896
  lexer.string_nest = 0
1934
1897
 
1935
- lexer.lex_state = :expr_beg
1898
+ lexer.lex_state = :expr_value
1936
1899
  }
1937
1900
  compstmt tRCURLY
1938
1901
  {
@@ -2479,6 +2442,10 @@ keyword_variable: kNIL { result = s(:nil) }
2479
2442
  operation2: tIDENTIFIER | tCONSTANT | tFID | op
2480
2443
  operation3: tIDENTIFIER | tFID | op
2481
2444
  dot_or_colon: tDOT | tCOLON2
2445
+ call_op: tDOT
2446
+ #if defined(RUBY23)
2447
+ | tLONELY
2448
+ #endif
2482
2449
  opt_terms: | terms
2483
2450
  opt_nl: | tNL
2484
2451
  rparen: opt_nl tRPAREN
data/lib/ruby_parser_extras.rb CHANGED
@@ -91,7 +91,7 @@ class RPStringScanner < StringScanner
91
91
  end
92
92
 
93
93
  module RubyParserStuff
94
- VERSION = "3.8.1" unless constants.include? "VERSION" # SIGH
94
+ VERSION = "3.8.2" unless constants.include? "VERSION" # SIGH
95
95
 
96
96
  attr_accessor :lexer, :in_def, :in_single, :file
97
97
  attr_reader :env, :comments
@@ -557,8 +557,15 @@ module RubyParserStuff
557
557
  end
558
558
  end
559
559
 
560
- def new_call recv, meth, args = nil
561
- result = s(:call, recv, meth)
560
+ def new_call recv, meth, args = nil, call_op = :'.'
561
+ result = case call_op.to_sym
562
+ when :'.'
563
+ s(:call, recv, meth)
564
+ when :'&.'
565
+ s(:safe_call, recv, meth)
566
+ else
567
+ raise "unknown call operator: `#{type.inspect}`"
568
+ end
562
569
 
563
570
  # TODO: need a test with f(&b) to produce block_pass
564
571
  # TODO: need a test with f(&b) { } to produce warning
@@ -577,6 +584,22 @@ module RubyParserStuff
577
584
  result
578
585
  end
579
586
 
587
+ def new_attrasgn recv, meth, call_op
588
+ meth = :"#{meth}="
589
+
590
+ result = case call_op.to_sym
591
+ when :'.'
592
+ s(:attrasgn, recv, meth)
593
+ when :'&.'
594
+ s(:safe_attrasgn, recv, meth)
595
+ else
596
+ raise "unknown call operator: `#{type.inspect}`"
597
+ end
598
+
599
+ result.line = recv.line
600
+ result
601
+ end
602
+
580
603
  def new_case expr, body, line
581
604
  result = s(:case, expr)
582
605
 
@@ -745,6 +768,23 @@ module RubyParserStuff
745
768
  result
746
769
  end
747
770
 
771
+ def new_op_asgn2 val
772
+ recv, call_op, meth, op, arg = val
773
+ meth = :"#{meth}="
774
+
775
+ result = case call_op.to_sym
776
+ when :'.'
777
+ s(:op_asgn2, recv, meth, op.to_sym, arg)
778
+ when :'&.'
779
+ s(:safe_op_asgn2, recv, meth, op.to_sym, arg)
780
+ else
781
+ raise "unknown call operator: `#{type.inspect}`"
782
+ end
783
+
784
+ result.line = recv.line
785
+ result
786
+ end
787
+
748
788
  def new_regexp val
749
789
  node = val[1] || s(:str, '')
750
790
  options = val[2]