ruby_parser 3.0.0.a2 → 3.0.0.a3

data/lib/ruby19_parser.y

@@ -7,16 +7,18 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD kSUPER
       kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD kWHILE_MOD
       kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND k__LINE__
-      k__FILE__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tLABEL tCVAR tNTH_REF
-      tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT tREGEXP_END tUPLUS
-      tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ tGEQ tLEQ tANDOP
-      tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF tASET tLSHFT tRSHFT
-      tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN tLPAREN2 tRPAREN tLPAREN_ARG
-      tLBRACK tLBRACK2 tRBRACK tLBRACE tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2
-      tTILDE tPERCENT tDIVIDE tPLUS tMINUS tLT tGT tPIPE tBANG tCARET
-      tLCURLY tRCURLY tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
-      tWORDS_BEG tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
-      tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAST_TOKEN tLAMBDA tLAMBEG
+      k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
+      tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
+      tREGEXP_END tUPLUS tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ
+      tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF
+      tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN
+      tLPAREN2 tRPAREN tLPAREN_ARG tLBRACK tLBRACK2 tRBRACK tLBRACE
+      tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2 tTILDE tPERCENT tDIVIDE
+      tPLUS tMINUS tLT tGT tPIPE tBANG tCARET tLCURLY tRCURLY
+      tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
+      tWORDS_BEG tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END
+      tSTRING tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAST_TOKEN
+      tLAMBDA tLAMBEG
 
 prechigh
   right    tBANG tTILDE tUPLUS
@@ -48,9 +50,36 @@ rule
          program:   {
                       self.lexer.lex_state = :expr_beg
                     }
-                    compstmt
+                    top_compstmt
                     {
-                      result = val[1]
+                      result = new_compstmt val
+                    }
+
+    top_compstmt: top_stmts opt_terms
+                    {
+                      result = val[0]
+                    }
+
+       top_stmts: none
+                | top_stmt
+                | top_stmts terms top_stmt
+                    {
+                      result = self.block_append val[0], val[2]
+                    }
+                | error top_stmt
+
+        top_stmt: stmt
+                | klBEGIN
+                    {
+                      if (self.in_def || self.in_single > 0) then
+                        yyerror "BEGIN in method"
+                      end
+                      self.env.extend
+                    }
+                    tLCURLY top_compstmt tRCURLY
+                    {
+                      result = new_iter s(:preexe), nil, val[3] # TODO: add test?
+                      result = nil # TODO: since it isn't supposed to go in the AST
                     }
 
         bodystmt: compstmt opt_rescue opt_else opt_ensure
@@ -119,18 +148,6 @@ rule
                     {
                       result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
                     }
-                | klBEGIN
-                    {
-                      if (self.in_def || self.in_single > 0) then
-                        yyerror "BEGIN in method"
-                      end
-                      self.env.extend
-                    }
-                    tLCURLY compstmt tRCURLY
-                    {
-                      result = new_iter s(:preexe), nil, val[3] # TODO: add test?
-                      result = nil # TODO: since it isn't supposed to go in the AST
-                    }
                 | klEND tLCURLY compstmt tRCURLY
                     {
                       if (self.in_def || self.in_single > 0) then
@@ -138,10 +155,7 @@ rule
                       end
                       result = new_iter s(:postexe), nil, val[2]
                     }
-                | lhs tEQL command_call
-                    {
-                      result = self.node_assign val[0], val[2]
-                    }
+                | command_asgn
                 | mlhs tEQL command_call
                     {
                       result = new_masgn val[0], val[2], :wrap
@@ -150,7 +164,7 @@ rule
                     {
                       result = new_op_asgn val
                     }
-                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN command_call
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_call
                     {
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
@@ -162,6 +176,10 @@ rule
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
                     }
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
+                    {
+                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
+                    }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
@@ -184,6 +202,15 @@ rule
                     }
                 | expr
 
+    command_asgn: lhs tEQL command_call
+                    {
+                      result = self.node_assign val[0], val[2]
+                    }
+                | lhs tEQL command_asgn
+                    {
+                      result = self.node_assign val[0], val[2]
+                    }
+
             expr: command_call
                 | expr kAND expr
                     {
@@ -193,13 +220,13 @@ rule
                     {
                       result = logop(:or, val[0], val[2])
                     }
-                | kNOT expr
+                | kNOT opt_nl expr
                     {
-                      result = s(:not, val[1])
+                      result = s(:call, val[2], :"!")
                     }
                 | tBANG command_call
                     {
-                      result = s(:not, val[1])
+                      result = s(:call, val[1], :"!")
                     }
                 | arg
 
@@ -210,21 +237,6 @@ rule
 
     command_call: command
                 | block_command
-                | kRETURN call_args
-                    {
-                      line = val[0].last
-                      result = s(:return, ret_args(val[1])).line(line)
-                    }
-                | kBREAK call_args
-                    {
-                      line = val[0].last
-                      result = s(:break, ret_args(val[1])).line(line)
-                    }
-                | kNEXT call_args
-                    {
-                      line = val[0].last
-                      result = s(:next, ret_args(val[1])).line(line)
-                    }
 
    block_command: block_call
                 | block_call tDOT operation2 command_args
@@ -241,7 +253,7 @@ rule
                       self.env.extend(:dynamic)
                       result = self.lexer.lineno
                     }
-                    opt_block_var
+                    opt_block_param
                     {
                       result = self.env.dynamic.keys
                     }
@@ -297,15 +309,30 @@ rule
                     {
                       result = new_yield val[1]
                     }
+                | kRETURN call_args
+                    {
+                      line = val[0].last
+                      result = s(:return, ret_args(val[1])).line(line)
+                    }
+                | kBREAK call_args
+                    {
+                      line = val[0].last
+                      result = s(:break, ret_args(val[1])).line(line)
+                    }
+                | kNEXT call_args
+                    {
+                      line = val[0].last
+                      result = s(:next, ret_args(val[1])).line(line)
+                    }
 
             mlhs: mlhs_basic
-                | tLPAREN mlhs_entry rparen
+                | tLPAREN mlhs_inner rparen
                     {
                       result = val[1]
                     }
 
-      mlhs_entry: mlhs_basic
-                | tLPAREN mlhs_entry rparen
+      mlhs_inner: mlhs_basic
+                | tLPAREN mlhs_inner rparen
                     {
                       result = s(:masgn, s(:array, val[1]))
                     }
@@ -322,21 +349,45 @@ rule
                     {
                       result = s(:masgn, val[0] << s(:splat, val[2]))
                     }
+                | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
+                    {
+                      ary = list_append val[0], s(:splat, val[2])
+                      ary.concat val[4][1..-1]
+                      result = s(:masgn, ary)
+                    }
                 | mlhs_head tSTAR
                     {
                       result = s(:masgn, val[0] << s(:splat))
                     }
+                | mlhs_head tSTAR tCOMMA mlhs_post
+                    {
+                      ary = list_append val[0], s(:splat)
+                      ary.concat val[3][1..-1]
+                      result = s(:masgn, ary)
+                    }
                 | tSTAR mlhs_node
                     {
                       result = s(:masgn, s(:array, s(:splat, val[1])))
                     }
+                | tSTAR mlhs_node tCOMMA mlhs_post
+                    {
+                      ary = s(:array, s(:splat, val[1]))
+                      ary.concat val[3][1..-1]
+                      result = s(:masgn, ary)
+                    }
                 | tSTAR
                     {
                       result = s(:masgn, s(:array, s(:splat)))
                     }
+                | tSTAR tCOMMA mlhs_post
+                    {
+                      ary = s(:array, s(:splat))
+                      ary.concat val[2][1..-1]
+                      result = s(:masgn, ary)
+                    }
 
        mlhs_item: mlhs_node
-                | tLPAREN mlhs_entry rparen
+                | tLPAREN mlhs_inner rparen
                     {
                       result = val[1]
                     }
@@ -350,6 +401,15 @@ rule
                       result = val[0] << val[1].compact
                     }
 
+       mlhs_post: mlhs_item
+                    {
+                      result = s(:array, val[0])
+                    }
+                | mlhs_post tCOMMA mlhs_item
+                    {
+                      result = list_append val[0], val[2]
+                    }
+
        mlhs_node: user_variable
                     {
                       result = self.assignable val[0]
@@ -358,7 +418,7 @@ rule
                     {
                       result = self.assignable val[0]
                     }
-                | primary_value tLBRACK2 aref_args tRBRACK
+                | primary_value tLBRACK2 opt_call_args rbracket
                     {
                       result = self.aryset val[0], val[2]
                     }
@@ -403,7 +463,7 @@ rule
                     {
                       result = self.assignable val[0]
                     }
-                | primary_value tLBRACK2 aref_args tRBRACK
+                | primary_value tLBRACK2 opt_call_args rbracket
                     {
                       result = self.aryset val[0], val[2]
                     }
@@ -491,19 +551,21 @@ rule
                       result = new_undef val[0], val[3]
                     }
 
-              op: tPIPE    | tCARET     | tAMPER2 | tCMP   | tEQ     | tEQQ
-                | tMATCH   | tGT        | tGEQ    | tLT    | tLEQ    | tLSHFT
-                | tRSHFT   | tPLUS      | tMINUS  | tSTAR2 | tSTAR   | tDIVIDE
-                | tPERCENT | tPOW       | tTILDE  | tUPLUS | tUMINUS | tAREF
-                | tASET    | tBACK_REF2
-
-        reswords: k__LINE__ | k__FILE__   | klBEGIN | klEND  | kALIAS  | kAND
-                | kBEGIN    | kBREAK      | kCASE   | kCLASS | kDEF    | kDEFINED
-                | kDO       | kELSE       | kELSIF  | kEND   | kENSURE | kFALSE
-                | kFOR      | kIN         | kMODULE | kNEXT  | kNIL    | kNOT
-                | kOR       | kREDO       | kRESCUE | kRETRY | kRETURN | kSELF
-                | kSUPER    | kTHEN       | kTRUE   | kUNDEF | kWHEN   | kYIELD
-                | kIF       | kUNLESS     | kWHILE  | kUNTIL
+                op: tPIPE    | tCARET  | tAMPER2  | tCMP  | tEQ     | tEQQ
+                |   tMATCH   | tNMATCH | tGT      | tGEQ  | tLT     | tLEQ
+                |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS  | tSTAR2
+                |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tBANG   | tTILDE
+                |   tUPLUS   | tUMINUS | tAREF    | tASET | tBACK_REF2
+
+        reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
+                | kALIAS    | kAND      | kBEGIN        | kBREAK  | kCASE
+                | kCLASS    | kDEF      | kDEFINED      | kDO     | kELSE
+                | kELSIF    | kEND      | kENSURE       | kFALSE  | kFOR
+                | kIN       | kMODULE   | kNEXT         | kNIL    | kNOT
+                | kOR       | kREDO     | kRESCUE       | kRETRY  | kRETURN
+                | kSELF     | kSUPER    | kTHEN         | kTRUE   | kUNDEF
+                | kWHEN     | kYIELD    | kIF           | kUNLESS | kWHILE
+                | kUNTIL
 
              arg: lhs tEQL arg
                     {
@@ -512,13 +574,17 @@ rule
                 | lhs tEQL arg kRESCUE_MOD arg
                     {
                       result = self.node_assign val[0], s(:rescue, val[2], new_resbody(s(:array), val[4]))
-                      # result.line = val[0].line
                     }
                 | var_lhs tOP_ASGN arg
                     {
                       result = new_op_asgn val
                     }
-                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN arg
+                | var_lhs tOP_ASGN arg kRESCUE_MOD arg
+                    {
+                      result = new_op_asgn val
+                      result = self.node_assign s(:rescue, result, new_resbody(s(:array), val[4]))
+                    }
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg
                     {
                       val[2][0] = :arglist
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
@@ -664,7 +730,7 @@ rule
                     }
                 | tBANG arg
                     {
-                      result = new_call val[1], :"!@"
+                      result = new_call val[1], :"!"
                     }
                 | tTILDE arg
                     {
@@ -695,10 +761,10 @@ rule
                     {
                       result = s(:defined, val[2])
                     }
-                | arg tEH arg tCOLON arg
+                | arg tEH arg opt_nl tCOLON arg
                     {
                       lexer.tern.pop
-                      result = s(:if, val[0], val[2], val[4])
+                      result = s(:if, val[0], val[2], val[5])
                     }
                 | primary
 
@@ -708,30 +774,17 @@ rule
                     }
 
        aref_args: none
-                | command opt_nl
-                    {
-                      warning 'parenthesize argument(s) for future version'
-                      result = s(:array, val[0])
-                    }
                 | args trailer
                     {
                       result = val[0]
                     }
-                | args tCOMMA tSTAR arg opt_nl
-                    {
-                      result = self.arg_concat val[0], val[3]
-                    }
-                | assocs trailer
-                    {
-                      result = s(:array, s(:hash, *val[0].values))
-                    }
                 | args tCOMMA assocs trailer
                     {
                       result = val[0] << s(:hash, *val[2].values)
                     }
-                | tSTAR arg opt_nl
+                | assocs trailer
                     {
-                      result = s(:array, s(:splat, val[1]))
+                      result = s(:array, s(:hash, *val[0].values))
                     }
 
       paren_args: tLPAREN2 opt_call_args rparen
@@ -739,6 +792,9 @@ rule
                       result = val[1]
                     }
 
+  opt_paren_args: none
+                | paren_args
+
    opt_call_args: none
                     {
                       result = val[0]
@@ -751,20 +807,16 @@ rule
                     {
                       result = val[0]
                     }
-                | block_call
+                | args tCOMMA assocs tCOMMA
                     {
                       warning "parenthesize argument(s) for future version"
-                      result = s(:array, val[0])
+                      result = val[0].add val[2]
                     }
-                | args tCOMMA block_call
+                | assocs tCOMMA
                     {
-                      warning "parenthesize argument(s) for future version"
-                      result = val[0].add val[2]
+                      result = val[0]
                     }
 
-  opt_paren_args: none
-                | paren_args
-
        call_args: command
                     {
                       warning "parenthesize argument(s) for future version"
@@ -774,129 +826,28 @@ rule
                     {
                       result = self.arg_blk_pass val[0], val[1]
                     }
-                | args tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat val[0], val[3]
-                      result = self.arg_blk_pass result, val[4]
-                    }
-                | args tCOMMA tSTAR arg_value tCOMMA args opt_block_arg
-                    {
-                      result = self.arg_concat val[0], val[3]
-                      val[5][1..-1].each {|a| result << a }
-                      result = self.arg_blk_pass result, val[6]
-                    }
                 | assocs opt_block_arg
                     {
                       result = s(:array, s(:hash, *val[0].values))
                       result = self.arg_blk_pass result, val[1]
                     }
-                | assocs tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3]
-                      result = self.arg_blk_pass result, val[4]
-                    }
                 | args tCOMMA assocs opt_block_arg
                     {
                       result = val[0] << s(:hash, *val[2].values)
                       result = self.arg_blk_pass result, val[3]
                     }
-                | args tCOMMA assocs tCOMMA tSTAR arg opt_block_arg
-                    {
-                      val[0] << s(:hash, *val[2].values)
-                      result = self.arg_concat val[0], val[5]
-                      result = self.arg_blk_pass result, val[6]
-                    }
-                | tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_blk_pass s(:splat, val[1]), val[2]
-                    }
-                | block_arg
-
-      call_args2: arg_value tCOMMA args opt_block_arg
-                    {
-                      args = self.list_prepend val[0], val[2]
-                      result = self.arg_blk_pass args, val[3]
-                    }
-                | arg_value tCOMMA block_arg
-                    {
-                      result = self.arg_blk_pass val[0], val[2]
-                    }
-                | arg_value tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat s(:array, val[0]), val[3]
-                      result = self.arg_blk_pass result, val[4]
-                    }
-                | arg_value tCOMMA args tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
-                      result = self.arg_blk_pass result, val[6]
-                    }
-                | assocs opt_block_arg
-                    {
-                      result = s(:array, s(:hash, *val[0].values))
-                      result = self.arg_blk_pass result, val[1]
-                    }
-                | assocs tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = s(:array, s(:hash, *val[0].values), val[3])
-                      result = self.arg_blk_pass result, val[4]
-                    }
-                | arg_value tCOMMA assocs opt_block_arg
-                    {
-                      result = s(:array, val[0], s(:hash, *val[2].values))
-                      result = self.arg_blk_pass result, val[3]
-                    }
-                | arg_value tCOMMA args tCOMMA assocs opt_block_arg
-                    {
-                      result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values))
-                      result = self.arg_blk_pass result, val[5]
-                    }
-                | arg_value tCOMMA assocs tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
-                      result = self.arg_blk_pass result, val[6]
-                    }
-                | arg_value tCOMMA args tCOMMA assocs tCOMMA tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
-                      result = self.arg_blk_pass result, val[8]
-                    }
-                | tSTAR arg_value opt_block_arg
-                    {
-                      result = self.arg_blk_pass s(:splat, val[1]), val[2]
-                    }
                 | block_arg
 
     command_args:   {
                       result = lexer.cmdarg.stack.dup
                       lexer.cmdarg.push true
                     }
-                    open_args
+                      call_args
                     {
                       lexer.cmdarg.stack.replace val[0]
                       result = val[1]
                     }
 
-       open_args: call_args
-                | tLPAREN_ARG
-                    {
-                      lexer.lex_state = :expr_endarg
-                    }
-                    tRPAREN
-                    {
-                      warning "don't put space before argument parentheses"
-                      result = nil
-                    }
-                | tLPAREN_ARG call_args2
-                    {
-                      lexer.lex_state = :expr_endarg
-                    }
-                    tRPAREN
-                    {
-                      warning "don't put space before argument parentheses"
-                      result = val[1]
-                    }
-
        block_arg: tAMPER arg_value
                     {
                       result = s(:block_pass, val[1])
@@ -912,10 +863,18 @@ rule
                     {
                       result = s(:array, val[0])
                     }
+                | tSTAR arg_value
+                    {
+                      result = s(:array, s(:splat, val[1]))
+                    }
                 | args tCOMMA arg_value
                     {
                       result = self.list_append val[0], val[2]
                     }
+                | args tCOMMA tSTAR arg_value
+                    {
+                      result = self.list_append val[0], s(:splat, val[3])
+                    }
 
             mrhs: args tCOMMA arg_value
                     {
@@ -978,10 +937,6 @@ rule
                     {
                       result = s(:colon3, val[1].to_sym)
                     }
-                | primary_value tLBRACK2 aref_args tRBRACK
-                    {
-                      result = new_aref val
-                    }
                 | tLBRACK aref_args tRBRACK
                     {
                       result = val[1] || s(:array)
@@ -1010,6 +965,14 @@ rule
                     {
                       result = s(:defined, val[3])
                     }
+                | kNOT tLPAREN2 expr rparen
+                    {
+                      raise "no2: #{val.inspect}"
+                    }
+                | kNOT tLPAREN2 rparen
+                    {
+                      raise "no3: #{val.inspect}"
+                    }
                 | operation brace_block
                     {
                       oper, iter = val[0], val[1]
@@ -1069,10 +1032,6 @@ rule
                     {
                       result = new_case nil, val[2]
                     }
-                | kCASE opt_terms kELSE compstmt kEND # TODO: need a test
-                    {
-                      result = new_case nil, val[3]
-                    }
                 | kFOR for_var kIN
                     {
                       lexer.cond.push true
@@ -1206,12 +1165,10 @@ rule
            k_end: kEND
 
             then: term
-                | tCOLON
                 | kTHEN
                 | term kTHEN
 
               do: term
-                | tCOLON
                 | kDO_COND
 
          if_tail: opt_else
@@ -1232,85 +1189,138 @@ rule
                       val[0].delete_at 1 if val[0][1].nil? # HACK
                     }
 
-       block_par: mlhs_item
+          f_marg: f_norm_arg
                     {
-                      result = s(:array, val[0])
+                      raise "no4: #{val.inspect}"
                     }
-                | block_par tCOMMA mlhs_item
+                | tLPAREN f_margs rparen
                     {
-                      result = self.list_append val[0], val[2]
+                      raise "no5: #{val.inspect}"
                     }
 
-       block_var: block_par
+     f_marg_list: f_marg
                     {
-                      result = block_var val[0], nil, nil
+                      raise "no6: #{val.inspect}"
                     }
-                | block_par tCOMMA
+                | f_marg_list tCOMMA f_marg
                     {
-                      result = block_var val[0], nil, nil
+                      raise "no7: #{val.inspect}"
                     }
-                | block_par tCOMMA tAMPER lhs
+
+         f_margs: f_marg_list
                     {
-                      result = block_var val[0], nil, val[3]
+                      raise "no8: #{val.inspect}"
                     }
-                | block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs
+                | f_marg_list tCOMMA tSTAR f_norm_arg
                     {
-                      result = block_var val[0], val[3], val[6]
+                      raise "no9: #{val.inspect}"
                     }
-                | block_par tCOMMA tSTAR tCOMMA tAMPER lhs
+                | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                     {
-                      result = block_var val[0], s(:splat), val[5]
+                      raise "no10: #{val.inspect}"
                     }
-                | block_par tCOMMA tSTAR lhs
+                | f_marg_list tCOMMA tSTAR
                     {
-                      result = block_var val[0], val[3], nil
+                      raise "no11: #{val.inspect}"
                     }
-                | block_par tCOMMA tSTAR
+                | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
                     {
-                      result = block_var val[0], s(:splat), nil
+                      raise "no12: #{val.inspect}"
                     }
-                | tSTAR lhs tCOMMA tAMPER lhs
+                | tSTAR f_norm_arg
                     {
-                      result = block_var nil, val[1], val[4]
+                      raise "no13: #{val.inspect}"
                     }
-                | tSTAR tCOMMA tAMPER lhs
+                | tSTAR f_norm_arg tCOMMA f_marg_list
                     {
-                      result = block_var nil, s(:splat), val[3]
+                      raise "no14: #{val.inspect}"
                     }
-                | tSTAR lhs
+                | tSTAR
                     {
-                      result = block_var nil, val[1], nil
+                      raise "no15: #{val.inspect}"
                     }
-                | tSTAR
+                | tSTAR tCOMMA f_marg_list
+                    {
+                      raise "no16: #{val.inspect}"
+                    }
+
+     block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "1"
+                    }
+                | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_var nil, s(:splat), nil
+                      result = block_args19 val, "2"
                     }
-                | tAMPER lhs
+                | f_arg tCOMMA f_block_optarg opt_f_block_arg
                     {
-                      result = block_var nil, nil, val[1]
+                      result = block_args19 val, "3"
+                    }
+                | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "4"
+                    }
+                | f_arg tCOMMA f_rest_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "5"
+                    }
+                | f_arg tCOMMA
+                    {
+                      result = block_args19 val, "6"
+                    }
+                | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "7"
+                    }
+                | f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "8"
+                    }
+                | f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "9"
+                    }
+                | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "10"
+                    }
+                | f_block_optarg opt_f_block_arg
+                    {
+                      result = block_args19 val, "11"
+                    }
+                | f_block_optarg tCOMMA f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "12"
+                    }
+                | f_rest_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "13"
+                    }
+                | f_rest_arg tCOMMA f_arg opt_f_block_arg
+                    {
+                      result = block_args19 val, "14"
+                    }
+                | f_block_arg
+                    {
+                      result = block_args19 val, "15"
                     }
-                ;
 
-   opt_block_var: none
-                | tPIPE tPIPE
+ opt_block_param: none
+                | block_param_def
+
+ block_param_def: tPIPE opt_bv_decl tPIPE
                     {
-                      result = 0
-                      self.lexer.command_start = true
+                      raise "no17: #{val.inspect}"
                     }
                 | tOROP
                     {
                       result = 0
                       self.lexer.command_start = true
                     }
-                | tPIPE block_var tPIPE
+                | tPIPE block_param opt_bv_decl tPIPE
                     {
                       result = val[1]
-                      self.lexer.command_start = true
-                    }
-                | tPIPE tAMPER block_var tPIPE
-                    {
-                      result = s(:lasgn, :"&block")
-                      self.lexer.command_start = true
+                      result.concat val[2] if val[2]
                     }
 
      opt_bv_decl: none
@@ -1323,17 +1333,13 @@ rule
                 | bv_decls tCOMMA bvar
                     {
                       result = val[0] << val[2]
+                      raise "no18: #{val.inspect}"
                     }
 
             bvar: tIDENTIFIER
                 | f_bad_arg
 
-          lambda: lambda_body
-                    {
-                      call = new_call nil, :lambda
-                      result = s(:iter, call, 0, val[0])
-                    }
-                | f_larglist lambda_body
+          lambda: f_larglist lambda_body
                     {
                       case val[0].size
                       when 1
@@ -1372,7 +1378,7 @@ rule
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                    opt_block_var
+                    opt_block_param
                     {
                       result = self.env.dynamic.keys
                     }
@@ -1423,6 +1429,14 @@ rule
                     {
                       result = new_call val[0], val[2].to_sym
                     }
+                | primary_value tDOT paren_args
+                    {
+                      result = new_call val[0], :call
+                    }
+                | primary_value tCOLON2 paren_args
+                    {
+                      result = new_call val[0], :call
+                    }
                 | kSUPER paren_args
                     {
                       result = new_super val[1]
@@ -1431,13 +1445,17 @@ rule
                     {
                       result = s(:zsuper)
                     }
+                | primary_value tLBRACK2 opt_call_args rbracket
+                    {
+                      result = new_aref val
+                    }
 
      brace_block: tLCURLY
                     {
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                    opt_block_var
+                    opt_block_param
                     {
                       result = self.env.dynamic.keys
                     }
@@ -1455,7 +1473,7 @@ rule
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                 opt_block_var
+                 opt_block_param
                     {
                       result = self.env.dynamic.keys
                     }
@@ -1472,23 +1490,13 @@ rule
                     {
                       result = self.lexer.lineno
                     }
-                    when_args then compstmt cases
+                    args then compstmt cases
                     {
                       result = new_when(val[2], val[4])
                       result.line = val[1]
                       result << val[5] if val[5]
                     }
 
-       when_args: args
-                | args tCOMMA tSTAR arg_value
-                    {
-                      result = self.list_append val[0], new_when(val[3], nil)
-                    }
-                | tSTAR arg_value
-                    {
-                      result = s(:array, new_when(val[1], nil))
-                    }
-
            cases: opt_else | case_body
 
       opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
@@ -1737,6 +1745,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
                 | kFALSE    { result = s(:false) }
                 | k__FILE__ { result = s(:str, self.file) }
                 | k__LINE__ { result = s(:lit, lexer.src.current_line) }
+                | k__ENCODING__ { result = s(:str, "Unsupported!") }
 
          var_ref: user_variable
                     {
@@ -1877,12 +1886,18 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       result = val[0]
                     }
 
-           f_arg: f_norm_arg
+      f_arg_item: f_norm_arg
+                | tLPAREN f_margs rparen
+                    {
+                      raise "no19: #{val.inspect}"
+                    }
+
+           f_arg: f_arg_item
                     {
                       result = s(:args)
                       result << val[0].to_sym
                     }
-                | f_arg tCOMMA f_norm_arg
+                | f_arg tCOMMA f_arg_item
                     {
                       val[0] << val[2].to_sym
                       result = val[0]
@@ -1894,6 +1909,20 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       # TODO: detect duplicate names
                     }
 
+     f_block_opt: tIDENTIFIER tEQL primary_value
+                    {
+                      raise "no20: #{val.inspect}"
+                    }
+
+  f_block_optarg: f_block_opt
+                    {
+                      raise "no21: #{val.inspect}"
+                    }
+                | f_block_optarg tCOMMA f_block_opt
+                    {
+                      raise "no22: #{val.inspect}"
+                    }
+
         f_optarg: f_opt
                     {
                       result = s(:block, val[0])
@@ -1958,14 +1987,6 @@ keyword_variable: kNIL      { result = s(:nil)   }
                     {
                       result = val[0]
                     }
-                | args trailer
-                    {
-                      size = val[0].size
-                      if (size % 2 != 1) then # != 1 because of leading :array
-                        yyerror "Odd number (#{size}) list for Hash. #{val[0].inspect}"
-                      end
-                      result = val[0]
-                    }
 
           assocs: assoc
                 | assocs tCOMMA assoc