ruby_parser 2.3.1 → 3.0.0.a1

data/lib/{ruby_parser.y → ruby18_parser.y}

@@ -1,6 +1,6 @@
 # -*- racc -*-
 
-class RubyParser
+class Ruby18Parser
 
 token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
@@ -12,10 +12,10 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       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 tRBRACK tLBRACE tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2
+      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 tAWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
+      tWORDS_BEG tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
       tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAST_TOKEN
 
 prechigh
@@ -67,7 +67,7 @@ rule
                 | stmt
                 | stmts terms stmt
                     {
-                      result = self.block_append val[0], val[2]
+                      result = block_append val[0], val[2]
                     }
                 | error stmt
                     {
@@ -117,11 +117,11 @@ rule
                     }
                 | stmt kRESCUE_MOD stmt
                     {
-                      result = s(:rescue, val[0], s(:resbody, s(:array), val[2]))
+                      result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
                     }
                 | klBEGIN
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "BEGIN in method"
                       end
                       self.env.extend
@@ -133,14 +133,14 @@ rule
                     }
                 | klEND tLCURLY compstmt tRCURLY
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "END in method; use at_exit"
                       end
                       result = new_iter s(:postexe), nil, val[2]
                     }
                 | lhs tEQL command_call
                     {
-                      result = self.node_assign val[0], val[2]
+                      result = node_assign val[0], val[2]
                     }
                 | mlhs tEQL command_call
                     {
@@ -150,7 +150,7 @@ rule
                     {
                       result = new_op_asgn val
                     }
-                | primary_value "[" aref_args tRBRACK tOP_ASGN command_call
+                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN command_call
                     {
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
@@ -168,11 +168,11 @@ rule
                     }
                 | backref tOP_ASGN command_call
                     {
-                      self.backref_assign_error val[0]
+                      backref_assign_error val[0]
                     }
                 | lhs tEQL mrhs
                     {
-                      result = self.node_assign val[0], s(:svalue, val[2])
+                      result = node_assign val[0], s(:svalue, val[2])
                     }
                 | mlhs tEQL arg_value
                     {
@@ -352,27 +352,27 @@ rule
 
        mlhs_node: variable
                     {
-                      result = self.assignable val[0]
+                      result = assignable val[0]
                     }
-                | primary_value "[" aref_args tRBRACK
+                | primary_value tLBRACK2 aref_args tRBRACK
                     {
-                      result = self.aryset val[0], val[2]
+                      result = aryset val[0], val[2]
                     }
                 | primary_value tDOT tIDENTIFIER
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
+                      result = s(:attrasgn, val[0], :"#{val[2]}=")
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
+                      result = s(:attrasgn, val[0], :"#{val[2]}=")
                     }
                 | primary_value tDOT tCONSTANT
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
+                      result = s(:attrasgn, val[0], :"#{val[2]}=")
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "dynamic constant assignment"
                       end
 
@@ -380,7 +380,7 @@ rule
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "dynamic constant assignment"
                       end
 
@@ -388,16 +388,16 @@ rule
                     }
                 | backref
                     {
-                      self.backref_assign_error val[0]
+                      backref_assign_error val[0]
                     }
 
              lhs: variable
                     {
-                      result = self.assignable val[0]
+                      result = assignable val[0]
                     }
-                | primary_value "[" aref_args tRBRACK
+                | primary_value tLBRACK2 aref_args tRBRACK
                     {
-                      result = self.aryset val[0], val[2]
+                      result = aryset val[0], val[2]
                     }
                 | primary_value tDOT tIDENTIFIER
                     {
@@ -413,7 +413,7 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "dynamic constant assignment"
                       end
 
@@ -421,7 +421,7 @@ rule
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "dynamic constant assignment"
                       end
 
@@ -429,7 +429,7 @@ rule
                     }
                 | backref
                     {
-                      self.backref_assign_error val[0]
+                      backref_assign_error val[0]
                     }
 
            cname: tIDENTIFIER
@@ -495,22 +495,22 @@ rule
                 | kFOR      | kIN         | kMODULE | kNEXT  | kNIL    | kNOT
                 | kOR       | kREDO       | kRESCUE | kRETRY | kRETURN | kSELF
                 | kSUPER    | kTHEN       | kTRUE   | kUNDEF | kWHEN   | kYIELD
-                | kIF_MOD   | kUNLESS_MOD | kWHILE_MOD | kUNTIL_MOD | kRESCUE_MOD
+                | kIF       | kUNLESS     | kWHILE  | kUNTIL
 
              arg: lhs tEQL arg
                     {
-                      result = self.node_assign val[0], val[2]
+                      result = node_assign val[0], val[2]
                     }
                 | lhs tEQL arg kRESCUE_MOD arg
                     {
-                      result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
+                      result = 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 "[" aref_args tRBRACK tOP_ASGN arg
+                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN arg
                     {
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                       val[2][0] = :arglist
@@ -538,7 +538,7 @@ rule
                     }
                 | backref tOP_ASGN arg
                     {
-                      self.backref_assign_error val[0]
+                      backref_assign_error val[0]
                     }
                 | arg tDOT2 arg
                     {
@@ -560,101 +560,101 @@ rule
                     }
                 | arg tPLUS arg
                     {
-                      result = new_call val[0], :+, s(:arglist, val[2])
+                      result = new_call val[0], :+, argl(val[2])
                     }
                 | arg tMINUS arg
                     {
-                      result = new_call val[0], :-, s(:arglist, val[2])
+                      result = new_call val[0], :-, argl(val[2])
                     }
                 | arg tSTAR2 arg
                     {
-                      result = new_call val[0], :*, s(:arglist, val[2])
+                      result = new_call val[0], :*, argl(val[2])
                     }
                 | arg tDIVIDE arg
                     {
-                      result = new_call val[0], :"/", s(:arglist, val[2])
+                      result = new_call val[0], :"/", argl(val[2])
                     }
                 | arg tPERCENT arg
                     {
-                      result = new_call val[0], :%, s(:arglist, val[2])
+                      result = new_call val[0], :"%", argl(val[2])
                     }
                 | arg tPOW arg
                     {
-                      result = new_call val[0], :**, s(:arglist, val[2])
+                      result = new_call val[0], :**, argl(val[2])
                     }
                 | tUMINUS_NUM tINTEGER tPOW arg
                     {
-                      result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
+                      result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
                     }
                 | tUMINUS_NUM tFLOAT tPOW arg
                     {
-                      result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
+                      result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
                     }
                 | tUPLUS arg
                     {
                       if val[1][0] == :lit then
                         result = val[1]
                       else
-                        result = new_call val[1], :"+@", s(:arglist)
+                        result = new_call val[1], :"+@"
                       end
                     }
                 | tUMINUS arg
                     {
-                      result = new_call val[1], :"-@", s(:arglist)
+                      result = new_call val[1], :"-@"
                     }
                 | arg tPIPE arg
                     {
-                      result = new_call val[0], :"|", s(:arglist, val[2])
+                      result = new_call val[0], :"|", argl(val[2])
                     }
                 | arg tCARET arg
                     {
-                      result = new_call val[0], :"^", s(:arglist, val[2])
+                      result = new_call val[0], :"^", argl(val[2])
                     }
                 | arg tAMPER2 arg
                     {
-                      result = new_call val[0], :"&", s(:arglist, val[2])
+                      result = new_call val[0], :"&", argl(val[2])
                     }
                 | arg tCMP arg
                     {
-                      result = new_call val[0], :"<=>", s(:arglist, val[2])
+                      result = new_call val[0], :"<=>", argl(val[2])
                     }
                 | arg tGT arg
                     {
-                      result = new_call val[0], :">", s(:arglist, val[2])
+                      result = new_call val[0], :">", argl(val[2])
                     }
                 | arg tGEQ arg
                     {
-                      result = new_call val[0], :">=", s(:arglist, val[2])
+                      result = new_call val[0], :">=", argl(val[2])
                     }
                 | arg tLT arg
                     {
-                      result = new_call val[0], :"<", s(:arglist, val[2])
+                      result = new_call val[0], :"<", argl(val[2])
                     }
                 | arg tLEQ arg
                     {
-                      result = new_call val[0], :"<=", s(:arglist, val[2])
+                      result = new_call val[0], :"<=", argl(val[2])
                     }
                 | arg tEQ arg
                     {
-                      result = new_call val[0], :"==", s(:arglist, val[2])
+                      result = new_call val[0], :"==", argl(val[2])
                     }
                 | arg tEQQ arg
                     {
-                      result = new_call val[0], :"===", s(:arglist, val[2])
+                      result = new_call val[0], :"===", argl(val[2])
                     }
                 | arg tNEQ arg
                     {
                       val[0] = value_expr val[0] # TODO: port call_op and clean these
                       val[2] = value_expr val[2]
-                      result = s(:not, new_call(val[0], :"==", s(:arglist, val[2])))
+                      result = s(:not, new_call(val[0], :"==", argl(val[2])))
                     }
                 | arg tMATCH arg
                     {
-                      result = self.get_match_node val[0], val[2]
+                      result = get_match_node val[0], val[2]
                     }
                 | arg tNMATCH arg
                     {
-                      result = s(:not, self.get_match_node(val[0], val[2]))
+                      result = s(:not, get_match_node(val[0], val[2]))
                     }
                 | tBANG arg
                     {
@@ -663,19 +663,19 @@ rule
                 | tTILDE arg
                     {
                       val[2] = value_expr val[2]
-                      result = new_call val[1], :"~", s(:arglist)
+                      result = new_call val[1], :"~"
                     }
                 | arg tLSHFT arg
                     {
                       val[0] = value_expr val[0]
                       val[2] = value_expr val[2]
-                      result = new_call val[0], :"\<\<", s(:arglist, val[2])
+                      result = new_call val[0], :"\<\<", argl(val[2])
                     }
                 | arg tRSHFT arg
                     {
                       val[0] = value_expr val[0]
                       val[2] = value_expr val[2]
-                      result = new_call val[0], :">>", s(:arglist, val[2])
+                      result = new_call val[0], :">>", argl(val[2])
                     }
                 | arg tANDOP arg
                     {
@@ -691,6 +691,7 @@ rule
                     }
                 | arg tEH arg tCOLON arg
                     {
+                      lexer.tern.pop
                       result = s(:if, val[0], val[2], val[4])
                     }
                 | primary
@@ -712,7 +713,7 @@ rule
                     }
                 | args tCOMMA tSTAR arg opt_nl
                     {
-                      result = self.arg_concat val[0], val[3]
+                      result = arg_concat val[0], val[3]
                     }
                 | assocs trailer
                     {
@@ -752,92 +753,92 @@ rule
                     }
                 | args opt_block_arg
                     {
-                      result = self.arg_blk_pass val[0], val[1]
+                      result = 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]
+                      result = arg_concat val[0], val[3]
+                      result = arg_blk_pass result, val[4]
                     }
                 | assocs opt_block_arg
                     {
                       result = s(:array, s(:hash, *val[0].values))
-                      result = self.arg_blk_pass result, val[1]
+                      result = 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]
+                      result = arg_concat s(:array, s(:hash, *val[0].values)), val[3]
+                      result = 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]
+                      result = 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]
+                      result = arg_concat val[0], val[5]
+                      result = arg_blk_pass result, val[6]
                     }
                 | tSTAR arg_value opt_block_arg
                     {
-                      result = self.arg_blk_pass s(:splat, val[1]), val[2]
+                      result = 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]
+                      args = list_prepend val[0], val[2]
+                      result = arg_blk_pass args, val[3]
                     }
                 | arg_value tCOMMA block_arg
                     {
-                      result = self.arg_blk_pass val[0], val[2]
+                      result = 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]
+                      result = arg_concat s(:array, val[0]), val[3]
+                      result = 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]
+                      result = arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
+                      result = 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]
+                      result = 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]
+                      result = 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]
+                      result = 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]
+                      result = 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]
+                      result = arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
+                      result = 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]
+                      result = arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
+                      result = arg_blk_pass result, val[8]
                     }
                 | tSTAR arg_value opt_block_arg
                     {
-                      result = self.arg_blk_pass s(:splat, val[1]), val[2]
+                      result = arg_blk_pass s(:splat, val[1]), val[2]
                     }
                 | block_arg
 
@@ -880,7 +881,7 @@ rule
                     {
                       result = val[1]
                     }
-                | none_block_pass
+                | none
 
             args: arg_value
                     {
@@ -888,7 +889,7 @@ rule
                     }
                 | args tCOMMA arg_value
                     {
-                      result = self.list_append val[0], val[2]
+                      result = list_append val[0], val[2]
                     }
 
             mrhs: args tCOMMA arg_value
@@ -897,7 +898,7 @@ rule
                     }
                 | args tCOMMA tSTAR arg_value
                     {
-                      result = self.arg_concat val[0], val[3]
+                      result = arg_concat val[0], val[3]
                     }
                 | tSTAR arg_value
                     {
@@ -909,7 +910,7 @@ rule
                 | xstring
                 | regexp
                 | words
-                | awords
+                | qwords
                 | var_ref
                 | backref
                 | tFID
@@ -952,7 +953,7 @@ rule
                     {
                       result = s(:colon3, val[1].to_sym)
                     }
-                | primary_value "[" aref_args tRBRACK
+                | primary_value tLBRACK2 aref_args tRBRACK
                     {
                       result = new_aref val
                     }
@@ -1043,7 +1044,7 @@ rule
                     {
                       result = new_case nil, val[3]
                     }
-                | kFOR block_var kIN
+                | kFOR for_var kIN
                     {
                       lexer.cond.push true
                     }
@@ -1062,7 +1063,7 @@ rule
                     cpath superclass
                     {
                       self.comments.push self.lexer.comments
-                      if (self.in_def || self.in_single > 0) then
+                      if (in_def || in_single > 0) then
                         yyerror "class definition in method body"
                       end
                       self.env.extend
@@ -1078,12 +1079,12 @@ rule
                     }
                     expr
                     {
-                      result = self.in_def
+                      result = in_def
                       self.in_def = false
                     }
                     term
                     {
-                      result = self.in_single
+                      result = in_single
                       self.in_single = 0
                       self.env.extend
                     }
@@ -1100,7 +1101,7 @@ rule
                     {
                       self.comments.push self.lexer.comments
                       yyerror "module definition in method body" if
-                        self.in_def or self.in_single > 0
+                        in_def or in_single > 0
 
                       self.env.extend
                     }
@@ -1183,12 +1184,71 @@ rule
                       result = val[1]
                     }
 
-       block_var: lhs
+         for_var: lhs
                 | mlhs
                     {
                       val[0].delete_at 1 if val[0][1].nil? # HACK
                     }
 
+       block_par: mlhs_item
+                    {
+                      result = s(:array, val[0])
+                    }
+                | block_par tCOMMA mlhs_item
+                    {
+                      result = list_append val[0], val[2]
+                    }
+
+       block_var: block_par
+                    {
+                      result = block_var val[0], nil, nil
+                    }
+                | block_par tCOMMA
+                    {
+                      result = block_var val[0], nil, nil
+                    }
+                | block_par tCOMMA tAMPER lhs
+                    {
+                      result = block_var val[0], nil, val[3]
+                    }
+                | block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs
+                    {
+                      result = block_var val[0], val[3], val[6]
+                    }
+                | block_par tCOMMA tSTAR tCOMMA tAMPER lhs
+                    {
+                      result = block_var val[0], s(:splat), val[5]
+                    }
+                | block_par tCOMMA tSTAR lhs
+                    {
+                      result = block_var val[0], val[3], nil
+                    }
+                | block_par tCOMMA tSTAR
+                    {
+                      result = block_var val[0], s(:splat), nil
+                    }
+                | tSTAR lhs tCOMMA tAMPER lhs
+                    {
+                      result = block_var nil, val[1], val[4]
+                    }
+                | tSTAR tCOMMA tAMPER lhs
+                    {
+                      result = block_var nil, s(:splat), val[3]
+                    }
+                | tSTAR lhs
+                    {
+                      result = block_var nil, val[1], nil
+                    }
+                | tSTAR
+                    {
+                      result = block_var nil, s(:splat), nil
+                    }
+                | tAMPER lhs
+                    {
+                      result = block_var nil, nil, val[1]
+                    }
+                ;
+
    opt_block_var: none
                 | tPIPE tPIPE
                     {
@@ -1313,7 +1373,7 @@ rule
                     }
                     when_args then compstmt cases
                     {
-                      result = s(:when, val[2], val[4])
+                      result = new_when(val[2], val[4])
                       result.line = val[1]
                       result << val[5] if val[5]
                     }
@@ -1321,11 +1381,11 @@ rule
        when_args: args
                 | args tCOMMA tSTAR arg_value
                     {
-                      result = self.list_append val[0], s(:when, val[3], nil)
+                      result = list_append val[0], new_when(val[3], nil)
                     }
                 | tSTAR arg_value
                     {
-                      result = s(:array, s(:when, val[1], nil))
+                      result = s(:array, new_when(val[1], nil))
                     }
 
            cases: opt_else | case_body
@@ -1337,7 +1397,7 @@ rule
                       klasses ||= s(:array)
                       klasses << node_assign(var, s(:gvar, :"$!")) if var
 
-                      result = s(:resbody, klasses, body)
+                      result = new_resbody(klasses, body)
                       result << rest if rest # UGH, rewritten above
                     }
                 |
@@ -1381,7 +1441,7 @@ rule
           string: string1
                 | string string1
                     {
-                      result = self.literal_concat val[0], val[1]
+                      result = literal_concat val[0], val[1]
                     }
 
          string1: tSTRING_BEG string_contents tSTRING_END
@@ -1425,14 +1485,14 @@ rule
             word: string_content
                 | word string_content
                     {
-                      result = self.literal_concat val[0], val[1]
+                      result = literal_concat val[0], val[1]
                     }
 
-          awords: tAWORDS_BEG tSPACE tSTRING_END
+          qwords: tQWORDS_BEG tSPACE tSTRING_END
                     {
                       result = s(:array)
                     }
-                | tAWORDS_BEG qword_list tSTRING_END
+                | tQWORDS_BEG qword_list tSTRING_END
                     {
                       result = val[1]
                     }
@@ -1575,7 +1635,7 @@ xstring_contents: none
 
          var_lhs: variable
                     {
-                      result = self.assignable val[0]
+                      result = assignable val[0]
                     }
 
          backref: tNTH_REF  { result = s(:nth_ref,  val[0]) }
@@ -1649,12 +1709,16 @@ xstring_contents: none
 
       f_norm_arg: tCONSTANT
                     {
-                      yyerror "formal argument cannot be a constant: #{val[0]}"
+                      yyerror "formal argument cannot be a constant"
                     }
                 | tIVAR
                     {
                       yyerror "formal argument cannot be an instance variable"
                     }
+                | tGVAR
+                    {
+                      yyerror "formal argument cannot be a global variable"
+                    }
                 | tCVAR
                     {
                       yyerror "formal argument cannot be a class variable"
@@ -1680,7 +1744,7 @@ xstring_contents: none
 
            f_opt: tIDENTIFIER tEQL arg_value
                     {
-                      result = self.assignable val[0], val[2]
+                      result = assignable val[0], val[2]
                       # TODO: detect duplicate names
                     }
 
@@ -1690,7 +1754,7 @@ xstring_contents: none
                     }
                 | f_optarg tCOMMA f_opt
                     {
-                      result = self.block_append val[0], val[2]
+                      result = block_append val[0], val[2]
                     }
 
     restarg_mark: tSTAR2 | tSTAR
@@ -1699,7 +1763,7 @@ xstring_contents: none
                     {
                       # TODO: differs from parse.y - needs tests
                       name = val[1].to_sym
-                      self.assignable name
+                      assignable name
                       result = :"*#{name}"
                     }
                 | restarg_mark
@@ -1787,8 +1851,6 @@ xstring_contents: none
 
             none: { result = nil }
 
- none_block_pass: { result = nil }
-
 end
 
 ---- inner