opal 0.3.11 → 0.3.15

data/lib/opal/{parser.y → parser/grammar.y}

@@ -1,4 +1,4 @@
-class Opal::Parser < Racc::Parser
+class Opal::Grammar
 
 token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
       THEN ELSIF ELSE CASE WHEN WHILE UNTIL FOR BREAK NEXT
@@ -12,9 +12,9 @@ token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
       '::' '::@' OP_ASGN '=>' PAREN_BEG '(' ')' tLPAREN_ARG
       ARRAY_BEG ']' tLBRACE tLBRACE_ARG SPLAT '*' '&@' '&'
       '~' '%' '/' '+' '-' '<' '>' '|' '!' '^'
-      '{@' '}' BACK_REF2 SYMBOL_BEG STRING_BEG XSTRING_BEG REGEXP_BEG
+      LCURLY '}' BACK_REF2 SYMBOL_BEG STRING_BEG XSTRING_BEG REGEXP_BEG
       WORDS_BEG AWORDS_BEG STRING_DBEG STRING_DVAR STRING_END STRING
-      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL UNDEFINED NULL
+      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL
 
 prechigh
   right    '!' '~' '+@'
@@ -52,23 +52,29 @@ target:
 bodystmt:
     compstmt opt_rescue opt_else opt_ensure
     {
-      result = BodyStatementsNode.new val[0], val[1], val[2], val[3]
+      result = new_body val[0], val[1], val[2], val[3]
     }
 
 compstmt:
     stmts opt_terms
     {
-      result = val[0]
+      comp = new_compstmt val[0]
+      if comp and comp[0] == :begin and comp.size == 2
+        result = comp[1]
+        result.line = comp.line
+      else
+        result = comp
+      end
     }
 
 stmts:
     none
     {
-      result = StatementsNode.new []
+      result = new_block
     }
   | stmt
     {
-      result = StatementsNode.new [val[0]]
+      result = new_block val[0]
     }
   | stmts terms stmt
     {
@@ -78,35 +84,44 @@ stmts:
 
 stmt:
     ALIAS fitem fitem
+    {
+      result = s(:alias, val[1], val[2])
+    }
   | ALIAS GVAR GVAR
+    {
+      result = s(:valias, val[1].intern, val[2].intern)
+    }
   | ALIAS GVAR BACK_REF
   | ALIAS GVAR NTH_REF
+    {
+      result = s(:valias, val[1].intern, val[2].intern)
+    }
   | UNDEF undef_list
     {
-      result = UndefNode.new val[0], val[1]
+      result = val[1]
     }
   | stmt IF_MOD expr_value
     {
-      result = IfNode.new val[1], val[2], StatementsNode.new([val[0]]), [], val[1]
+      result = new_if val[2], val[0], nil
     }
   | stmt UNLESS_MOD expr_value
     {
-      result = IfModNode.new val[1], val[2], val[0]
+      result = new_if val[2], nil, val[0]
     }
   | stmt WHILE_MOD expr_value
     {
-      result = WhileNode.new val[1], val[2], StatementsNode.new([val[0]]), val[1]
+      result = s(:while, val[2], val[0], true)
     }
   | stmt UNTIL_MOD expr_value
     {
-      result = WhileNode.new val[1], val[2], StatementsNode.new([val[0]]), val[1]
+      result = s(:until, val[2], val[0], true)
     }
   | stmt RESCUE_MOD stmt
-  | klBEGIN '{@' compstmt '}'
-  | klEND '{@' compstmt '}'
+  | klBEGIN LCURLY compstmt '}'
+  | klEND LCURLY compstmt '}'
   | lhs '=' command_call
     {
-      result = AssignNode.new val[0], val[2], val[1]
+      result = new_assign val[0], val[2]
     }
   | mlhs '=' command_call
     {
@@ -114,7 +129,7 @@ stmt:
     }
   | var_lhs OP_ASGN command_call
     {
-      result = OpAsgnNode.new val[1], val[0], val[2]
+      result = new_op_asgn val[1].intern, val[0], val[2]
     }
   | primary_value '[@' aref_args ']' OP_ASGN command_call
     # {
@@ -122,12 +137,15 @@ stmt:
     # }
   | primary_value '.' IDENTIFIER OP_ASGN command_call
     {
-      result = OpAsgnNode.new(val[3], CallNode.new(val[0], val[2], []), val[4])
+      result = s(:op_asgn2, val[0], "#{val[2]}=".intern, val[3].intern, val[4])
     }
   | primary_value '.' CONSTANT OP_ASGN command_call
   | primary_value '::' IDENTIFIER OP_ASGN command_call
   | backref OP_ASGN command_call
   | lhs '=' mrhs
+    {
+      result = new_assign val[0], s(:svalue, val[2])
+    }
   | mlhs '=' arg_value
     {
       result = MlhsAssignNode.new val[1], val[0], val[2]
@@ -142,19 +160,22 @@ expr:
     command_call
   | expr AND expr
     {
-      result = AndNode.new val[1], val[0], val[2]
+      result = s(:and, val[0], val[2])
+      result.line = val[0].line
     }
   | expr OR expr
     {
-      result = OrNode.new val[1], val[0], val[2]
+      result = s(:or, val[0], val[2])
+      result.line = val[0].line
     }
   | NOT expr
     {
-      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
+      result = s(:not, val[1])
+      result.line = val[1].line
     }
   | '!' command_call
     {
-      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
+      result = s(:not, val[1])
     }
   | arg
 
@@ -166,15 +187,21 @@ command_call:
   | block_command
   | RETURN call_args
     {
-      result = ReturnNode.new val[0], val[1]
+      args = val[1]
+      args = args[1] if args.size == 2
+      result = s(:return, args)
     }
   | BREAK call_args
     {
-      result = BreakNode.new val[0], val[1]
+      args = val[1]
+      args = args[1] if args.size == 2
+      result = s(:break, args)
     }
   | NEXT call_args
     {
-      result = NextNode.new val[0], val[1]
+      args = val[1]
+      args = args[1] if args.size == 2
+      result = s(:next, args)
     }
 
 block_command:
@@ -188,12 +215,12 @@ cmd_brace_block:
 command:
     operation command_args =LOWEST
     {
-      result = CallNode.new nil, val[0], val[1]
+      result = new_call nil, val[0].intern, val[1]
     }
   | operation command_args cmd_brace_block
   | primary_value '.' operation2 command_args =LOWEST
     {
-      result = CallNode.new val[0], val[2], val[3]
+      result = new_call val[0], val[2].intern, val[3]
     }
   | primary_value '.' operation2 command_args cmd_brace_block
   | primary_value '::' operation2 command_args =LOWEST
@@ -203,11 +230,11 @@ command:
   | primary_value '::' operation2 command_args cmd_brace_block
   | SUPER command_args
     {
-      result = SuperNode.new val[0], val[1]
+      result = new_super val[1]
     }
   | YIELD command_args
     {
-      result = YieldNode.new val[0], val[1]
+      result = new_yield val[1]
     }
 
 mlhs:
@@ -276,16 +303,27 @@ mlhs_node:
 
 lhs:
     variable
+    {
+      result = new_assignable val[0]
+    }
   | primary_value '[@' aref_args ']'
     {
-      result = ArefNode.new val[0], val[2]
+      args = val[2]
+      args[0] = :arglist if args[0] == :array
+      result = s(:attrasgn, val[0], :[]=, args)
     }
   | primary_value '.' IDENTIFIER
     {
-      result = CallNode.new val[0], val[2], [[]]
+      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
     }
   | primary_value '::' IDENTIFIER
+    {
+      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
+    }
   | primary_value '.' CONSTANT
+    {
+      result = s(:attrasgn, val[0], "#{val[2]}=".intern, s(:arglist))
+    }
   | primary_value '::' CONSTANT
   | '::@' CONSTANT
   | backref
@@ -296,15 +334,15 @@ cname:
 cpath:
     '::@' cname
     {
-      result = "result = ['::', val[1]];"
+      result = s(:colon3, val[1].intern)
     }
   | cname
     {
-      result = [nil, val[0]]
+      result = val[0].intern
     }
   | primary_value '::' cname
     {
-      result = [val[0], val[2]]
+      result = s(:colon2, val[0], val[2].intern)
     }
 
 fname:
@@ -312,16 +350,30 @@ fname:
   | CONSTANT
   | FID
   | op
+    {
+      @lex_state = :expr_end
+      result = val[0]
+    }
   | reswords
+    {
+      @lex_state = :expr_end
+      result = val[0]
+    }
 
 fitem:
     fname
+    {
+      result = s(:lit, val[0].intern)
+    }
   | symbol
+    {
+      result = s(:lit, val[0])
+    }
 
 undef_list:
     fitem
     {
-      result = [val[0]]
+      result = s(:undef, val[0])
     }
   | undef_list ',' fitem
     {
@@ -347,20 +399,23 @@ reswords:
 arg:
     lhs '=' arg
     {
-      result = AssignNode.new val[0], val[2], val[1]
+      result = new_assign val[0], val[2]
     }
   | lhs '=' arg RESCUE_MOD arg
   | var_lhs OP_ASGN arg
     {
-      result = OpAsgnNode.new val[1], val[0], val[2]
+      result = new_op_asgn val[1].intern, val[0], val[2]
     }
   | primary_value '[@' aref_args ']' OP_ASGN arg
     {
-      result = OpAsgnNode.new val[4], ArefNode.new(val[0], val[2]), val[5]
+      args = val[2]
+      args[0] = :arglist if args[0] == :array
+      result = s(:op_asgn1, val[0], val[2], val[4].intern, val[5])
+      result.line = val[0].line
     }
   | primary_value '.' IDENTIFIER OP_ASGN arg
     {
-      result = OpAsgnNode.new(val[3], CallNode.new(val[0], val[2], [[]]), val[4])
+      result = s(:op_asgn2, val[0], "#{val[2]}=".intern, val[3].intern, val[4])
     }
   | primary_value '.' CONSTANT OP_ASGN arg
   | primary_value '::' IDENTIFIER OP_ASGN arg
@@ -369,124 +424,136 @@ arg:
   | backref OP_ASGN arg
   | arg '..' arg
     {
-      result = RangeNode.new val[1], val[0], val[2]
+      result = s(:dot2, val[0], val[2])
+      result.line = val[0].line
     }
   | arg '...' arg
     {
-      result = RangeNode.new val[1], val[0], val[2]
+      result = s(:dot3, val[0], val[2])
+      result.line = val[0].line
     }
   | arg '+' arg
     {
-      result = ArithmeticNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"+", s(:arglist, val[2])
     }
   | arg '-' arg
     {
-      result = ArithmeticNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"-", s(:arglist, val[2])
     }
   | arg '*' arg
     {
-      result = ArithmeticNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"*", s(:arglist, val[2])
     }
   | arg '/' arg
     {
-      result = ArithmeticNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"/", s(:arglist, val[2])
     }
   | arg '%' arg
     {
-      result = ArithmeticNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"%", s(:arglist, val[2])
     }
   | arg '**' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"**", s(:arglist, val[2])
     }
+  | '-@NUM' INTEGER '**' arg
+  | '-@NUM' FLOAT '**' arg
   | '+@' arg
     {
-      result = UnaryNode.new({:line => val[0][:line], :value => '+'} , val[1])
+      result = new_call val[1], :"+@", s(:arglist)
+      result = val[1] if val[1][0] == :lit and Numeric === val[1][1]
     }
   | '-@' arg
     {
-      result = UnaryNode.new({:line => val[0][:line], :value => '-'} , val[1])
+      result = new_call val[1], :"-@", s(:arglist)
+      if val[1][0] == :lit and Numeric === val[1][1]
+        val[1][1] = -val[1][1]
+        result = val[1]
+      end
     }
   | arg '|' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"|", s(:arglist, val[2])
     }
   | arg '^' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"^", s(:arglist, val[2])
     }
   | arg '&' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"&", s(:arglist, val[2])
     }
   | arg '<=>' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"<=>", s(:arglist, val[2])
     }
   | arg '>' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = new_call val[0], :">", s(:arglist, val[2])
     }
   | arg '>=' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = new_call val[0], :">=", s(:arglist, val[2])
     }
   | arg '<' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = new_call val[0], :"<", s(:arglist, val[2])
     }
   | arg '<=' arg
     {
-      result = ComparisonNode.new val[1], val[0], val[2]
+      result = new_call val[0], :"<=", s(:arglist, val[2])
     }
   | arg '==' arg
     {
-      result = EqualNode.new val[0], val[1], val[2]
+      result = new_call val[0], :"==", s(:arglist, val[2])
     }
   | arg '===' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"===", s(:arglist, val[2])
     }
   | arg '!=' arg
     {
-      result = EqualNode.new val[0], val[1], val[2]
+      result = s(:not, new_call(val[0], :"==", s(:arglist, val[2])))
     }
   | arg '=~' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"=~", s(:arglist, val[2])
     }
   | arg '!~' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = s(:not, new_call(val[0], :"=~", s(:arglist, val[2])))
     }
   | '!' arg
     {
-      result = UnaryNode.new({:line => val[0][:line], :value => '!'} , val[1])
+      result = s(:not, val[1])
     }
   | '~' arg
     {
-      result = CallNode.new val[1], val[0], []
+      result = new_call val[1], :"~", s(:arglist)
     }
   | arg '<<' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :"<<", s(:arglist, val[2])
     }
   | arg '>>' arg
     {
-      result = CallNode.new val[0], val[1], [[val[2]]]
+      result = new_call val[0], :">>", s(:arglist, val[2])
     }
   | arg '&&' arg
     {
-      result = AndNode.new val[1], val[0], val[2]
+      result = s(:and, val[0], val[2])
+      result.line = val[0].line
     }
   | arg '||' arg
     {
-      result = OrNode.new val[1], val[0], val[2]
+      result = s(:or, val[0], val[2])
+      result.line = val[0].line
     }
   | DEFINED opt_nl arg
   | arg '?' arg ':' arg
     {
-      result = TernaryNode.new val[0], val[2], val[4]
+      result = s(:if, val[0], val[2], val[4])
+      result.line = val[0].line
     }
   | primary
 
@@ -496,30 +563,24 @@ arg_value:
 aref_args:
     none
     {
-      result = [[], nil]
+      result = nil
     }
-  | command opt_nl
   | args trailer
     {
-      result = [val[0], nil]
-    }
-  | args ',' SPLAT arg opt_nl
-    {
-      result = [val[0], val[3]]
+      result = val[0]
     }
   | assocs trailer
     {
-      result = [[HashNode.new(val[0], {}, {})], nil]
-    }
-  | SPLAT arg opt_nl
-    {
-      result = [[], val[1]]
+      result = s(:array, val[0])
+      #result.line = val[0].line
+      # FIXME:
+      result = s(:array)
     }
 
 paren_args:
     '(' none ')'
     {
-      result = [[]]
+      result = nil
     }
   | '(' call_args opt_nl ')'
     {
@@ -530,61 +591,36 @@ paren_args:
 
 opt_paren_args:
     none
-    {
-      result = []
-    }
   | paren_args
 
 call_args:
     command
     {
-      result = [[val[0]], nil, nil, nil]
+      result = s(:array, val[0])
     }
   | args opt_block_arg
     {
-      result = [val[0], nil, nil, val[1]]
-    }
-  | args ',' SPLAT arg_value opt_block_arg
-    {
-      result = [val[0], val[3], nil, val[4]]
+      result = val[0]
+      add_block_pass val[0], val[1]
     }
   | assocs opt_block_arg
     {
-      result = [nil, nil, val[0], val[1]]
-    }
-  | assocs ',' SPLAT arg_value opt_block_arg
-    {
-      result = [nil, val[3], val[0], val[4]]
+      result = s(:arglist, s(:hash, *val[0]))
+      add_block_pass result, val[1]
     }
   | args ',' assocs opt_block_arg
     {
-      result = [val[0], nil, val[2], val[3]]
-    }
-  | args ',' assocs ',' SPLAT arg opt_block_arg
-    {
-      result = [val[0], val[5], val[2], val[6]]
-    }
-  | SPLAT arg_value opt_block_arg
-    {
-      result = [nil, val[1], nil, val[2]]
+      result = val[0]
+      result << s(:hash, *val[2])
     }
   | block_arg
     {
-      result = [nil, nil, nil, val[0]]
+      result = s(:arglist)
+      add_block_pass result, val[0]
     }
 
 call_args2:
     arg_value ',' args opt_block_arg
-  | arg_value ',' block_arg
-  | arg_value ',' SPLAT arg_value opt_block_arg
-  | arg_value ',' args ',' SPLAT arg_value opt_block_arg
-  | assocs opt_block_arg
-  | assocs ',' SPLAT arg_value opt_block_arg
-  | arg_value ',' assocs opt_block_arg
-  | arg_value ',' args ',' assocs opt_block_arg
-  | arg_value ',' assocs ',' SPLAT arg_value opt_block_arg
-  | arg_value ',' args ',' assocs ',' SPLAT arg_value opt_block_arg
-  | SPLAT arg_value opt_block_arg
   | block_arg
 
 command_args:
@@ -601,7 +637,7 @@ open_args:
     call_args
   | tLPAREN_ARG ')'
     {
-      result = [[]]
+      result = nil
     }
   | tLPAREN_ARG call_args2 ')'
     {
@@ -611,7 +647,7 @@ open_args:
 block_arg:
     '&@' arg_value
     {
-      result = val[1]
+      result = s(:block_pass, val[1])
     }
 
 opt_block_arg:
@@ -627,17 +663,32 @@ opt_block_arg:
 args:
     arg_value
     {
-      result = [val[0]]
+      result = s(:array, val[0])
+    }
+  | SPLAT arg_value
+    {
+      result = s(:array, s(:splat, val[1]))
     }
   | args ',' arg_value
     {
       result = val[0] << val[2]
     }
+  | args ',' SPLAT arg_value
+    {
+      result  = val[0] << s(:splat, val[3])
+    }
 
 mrhs:
     args ',' arg_value
+    {
+      val[0] << val[2]
+      result = val[0]
+    }
   | args ',' SPLAT arg_value
   | SPLAT arg_value
+    {
+      result = s(:splat, val[1])
+    }
 
 primary:
     literal
@@ -649,74 +700,83 @@ primary:
   | var_ref
   | backref
   | FID
-  | BEGIN bodystmt END
+  | BEGIN
     {
-      result = BeginNode.new val[0], val[1], val[2]
+      result = @line
+    }
+    bodystmt END
+    {
+      result = s(:begin, val[2])
+      result.line = val[1]
     }
   | tLPAREN_ARG expr opt_nl ')'
   | PAREN_BEG compstmt ')'
     {
-      result = ParenNode.new val[0], val[1], val[2]
+      result = val[1] || s(:nil)
     }
   | primary_value '::' CONSTANT
     {
-      result = Colon2Node.new val[0], val[2]
+      result = s(:colon2, val[0], val[2].intern)
     }
   | '::@' CONSTANT
     {
-      result = Colon3Node.new val[1]
+      result = s(:colon3, val[1])
     }
   | primary_value '[@' aref_args ']'
     {
-      result = CallNode.new val[0], { :line => val[0].line, :value => '[]' }, val[2]
+      result = new_call val[0], :[], val[2]
     }
   | '[' aref_args ']'
     {
-      result = ArrayNode.new val[1], val[0], val[2]
+      result = val[1] || s(:array)
     }
   | '{' assoc_list '}'
     {
-      result = HashNode.new val[1], val[0], val[2]
+      result = s(:hash, *val[1])
     }
   | RETURN
     {
-      result = ReturnNode.new val[0], [nil]
+      result = s(:return)
     }
   | YIELD '(' call_args ')'
     {
-      result = YieldNode.new val[0], val[2]
+      result = new_yield val[2]
     }
   | YIELD '(' ')'
     {
-      result = YieldNode.new val[0], []
+      result = s(:yield)
     }
   | YIELD
     {
-      result = YieldNode.new val[0], []
+      result = s(:yield)
     }
   | DEFINED opt_nl '(' expr ')'
+    {
+      result = s(:defined, val[3])
+    }
   | operation brace_block
     {
-      result = CallNode.new nil, val[0], [[]]
-      result.block = val[1]
+      result = val[1]
+      result[1] = new_call(nil, val[0].intern, s(:arglist))
     }
   | method_call
   | method_call brace_block
     {
-      result = val[0];
-      result.block = val[1]
+      result = val[1]
+      result[1] = val[0]
     }
   | IF expr_value then compstmt if_tail END
     {
-      result = IfNode.new val[0], val[1], val[3], val[4], val[5]
+      result = new_if val[1], val[3], val[4]
     }
   | UNLESS expr_value then compstmt opt_else END
     {
-      result = IfNode.new val[0], val[1], val[3], val[4], val[5]
+      result = new_if val[1], val[4], val[3]
     }
   | WHILE
     {
       cond_push 1
+      result = @line
     }
     expr_value do
     {
@@ -724,72 +784,123 @@ primary:
     }
     compstmt END
     {
-      result = WhileNode.new val[0], val[2], val[5], val[6]
+      result = s(:while, val[2], val[5], true)
+      result.line = val[1]
     }
   | UNTIL
     {
-      result = "this.cond_push(1);"
+      cond_push 1
+      result = @line
     }
     expr_value do
     {
-      result = "this.cond_pop();"
+      cond_pop
     }
     compstmt END
     {
-      result = "result = ['while', val[0], val[2], val[5]];"
+      result = s(:until, val[2], val[5], true)
+      result.line = val[1]
     }
   | CASE expr_value opt_terms case_body END
     {
-      result = CaseNode.new val[0], val[1], val[3], val[4]
+      result = s(:case, val[1], *val[3])
+      result.line = val[1].line
     }
   | CASE opt_terms case_body END
     {
-      result = "result = ['case', null, val[2]];"
+      result = s(:case, nil, *val[2])
+      result.line = val[2].line
     }
   | CASE opt_terms ELSE compstmt END
+    {
+      result = s(:case, nil, val[3])
+      result.line = val[3].line
+    }
   | FOR block_var IN
     {
-      cond_push 1
+      result = "this.cond_push(1);"
     }
     expr_value do
     {
-      cond_pop
+      result = "this.cond_pop();"
     }
     compstmt END
+  | CLASS
     {
-      result = ForNode.new val[0], val[1], val[4], val[7], val[8]
+      result = @line
     }
-  | CLASS cpath superclass bodystmt END
+    cpath superclass
     {
-      result = ClassNode.new val[0], val[1], val[2], val[3], val[4]
+      # ...
     }
-  | CLASS '<<' expr term bodystmt END
+    bodystmt END
     {
-      result = ClassShiftNode.new val[0], val[2], val[4], val[5]
+      result = new_class val[2], val[3], val[5]
+      result.line = val[1]
+      result.end_line = @line
     }
-  | MODULE cpath bodystmt END
+  | CLASS '<<'
     {
-      result = ModuleNode.new val[0], val[1], val[2], val[3]
+      result = @line
     }
-  | DEF fname f_arglist bodystmt END
+    expr term
     {
-      result = DefNode.new val[0], nil, val[1], val[2], val[3], val[4]
+      # ...
     }
-  | DEF singleton dot_or_colon fname f_arglist bodystmt END
+    bodystmt END
     {
-      result = DefNode.new val[0], val[1], val[3], val[4], val[5], val[6]
+      result = new_sclass val[3], val[6]
+      result.line = val[2]
+    }
+  | MODULE
+    {
+      result = @line
+    }
+    cpath
+    {
+      # ...
+    }
+    bodystmt END
+    {
+      result = new_module val[2], val[4]
+      result.line = val[1]
+      result.end_line = @line
+    }
+  | DEF fname
+    {
+      result = @scope_line
+      push_scope
+    }
+    f_arglist bodystmt END
+    {
+      result = new_defn val[2], val[1], val[3], val[4]
+      pop_scope
+    }
+  | DEF singleton dot_or_colon
+    {
+       # ..
+    }
+    fname
+    {
+      result = @scope_line
+      push_scope
+    }
+    f_arglist bodystmt END
+    {
+      result = new_defs val[5], val[1], val[4], val[6], val[7]
+      pop_scope
     }
   | BREAK
     {
-      result = BreakNode.new val[0], []
+      result = s(:break)
     }
   | NEXT
     {
-      result = NextNode.new val[0], []
+      result = s(:next)
     }
   | REDO
     {
-      result = RedoNode.new val[0]
+      result = s(:redo)
     }
   | RETRY
 
@@ -812,65 +923,67 @@ if_tail:
     {
       result = val[0]
     }
-  | ELSIF expr_value then compstmt if_tail
+  | ELSIF
     {
-      result = [[val[0], val[1], val[3]]].concat val[4]
+      result = @line
+    }
+    expr_value then compstmt if_tail
+    {
+      result = s(:if, val[2], val[4], val[5])
+      result.line = val[1]
     }
 
 opt_else:
     none
-    {
-      result = []
-    }
   | ELSE compstmt
     {
-      result = [[val[0], val[1]]]
+      result = val[1]
     }
 
 block_var:
     block_var_args
     {
-      result = [val[0], nil]
+      result = val[0]
     }
 
 block_var_args:
     f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
     {
-      result = [val[0], val[2], val[4], val[5]]
+      result = new_block_args val[0], val[2], val[4], val[5]
     }
   | f_arg ',' f_block_optarg opt_f_block_arg
     {
-      result = [val[0], val[2], nil, val[3]]
+      result = new_block_args val[0], val[2], nil, val[3]
     }
   | f_arg ',' f_rest_arg opt_f_block_arg
     {
-      result = [val[0], nil, val[2], val[3]]
+      result = new_block_args val[0], nil, val[2], val[3]
     }
   | f_arg opt_f_block_arg
     {
-      result = [val[0], nil, nil, val[1]]
+      result = new_block_args val[0], nil, nil, val[1]
     }
   | f_block_optarg ',' f_rest_arg opt_f_block_arg
     {
-      result = [nil, val[0], val[2], val[3]]
+      result = new_block_args nil, val[0], val[2], val[3]
     }
   | f_block_optarg opt_f_block_arg
     {
-      result = [nil, val[0], nil, val[1]]
+      result = new_block_args nil, val[0], nil, val[1]
     }
   | f_rest_arg opt_f_block_arg
     {
-      result = [nil, nil, val[0], val[1]]
+      result = new_block_args nil, nil, val[0], val[1]
     }
   | f_block_arg
     {
-      result = [nil, nil, nil, val[0]]
+      result = new_block_args nil, nil, nil, val[0]
     }
 
 f_block_optarg:
     f_block_opt
     {
-      result = [val[0]]
+      result = s(:block, val[0])
     }
   | f_block_optarg ',' f_block_opt
     {
@@ -881,21 +994,18 @@ f_block_optarg:
 f_block_opt:
     IDENTIFIER '=' primary_value
     {
-      result = [val[0], val[2]]
+      result = new_assign new_assignable(s(:identifier, val[0].intern)), val[2]
     }
 
 opt_block_var:
     none
-    {
-      result = [nil]
-    }
   | '|' '|'
     {
-      result = [nil]
+      result = 0
     }
   | '||'
     {
-      result = [nil]
+      result = 0
     }
   | '|' block_var '|'
     {
@@ -905,18 +1015,21 @@ opt_block_var:
 do_block:
     DO_BLOCK
     {
-      # result = "print('doing half command');"
+      push_scope :block
+      result = @line
     }
     opt_block_var compstmt END
     {
-      result = BlockNode.new val[0], val[2], val[3], val[4]
+      result = new_iter nil, val[2], val[3]
+      result.line = val[1]
+      pop_scope
     }
 
 block_call:
     command do_block
     {
-      result = val[0]
-      val[0].block = val[1]
+      result = val[1]
+      result[1] = val[0]
     }
   | block_call '.' operation2 opt_paren_args
   | block_call '::' operation2 opt_paren_args
@@ -924,71 +1037,85 @@ block_call:
 method_call:
     operation paren_args
     {
-      result = CallNode.new nil, val[0], val[1]
+      result = new_call nil, val[0].intern, val[1]
     }
   | primary_value '.' operation2 opt_paren_args
     {
-      result = CallNode.new val[0], val[2], val[3]
+      result = new_call val[0], val[2].intern, val[3]
     }
   | primary_value '::' operation2 paren_args
   | primary_value '::' operation3
   | SUPER paren_args
     {
-      result = SuperNode.new val[0], val[1]
+      result = new_super val[1]
     }
   | SUPER
     {
-      result = SuperNode.new val[0], []
+      result = s(:zsuper)
     }
 
 brace_block:
-    '{@' opt_block_var compstmt '}'
+    LCURLY
     {
-      result = BlockNode.new val[0], val[1], val[2], val[3]
+      push_scope :block
+      result = @line
     }
-  | DO opt_block_var compstmt END
+    opt_block_var compstmt '}'
     {
-      result = BlockNode.new val[0], val[1], val[2], val[3]
+      result = new_iter nil, val[2], val[3]
+      result.line = val[1]
+      pop_scope
     }
-
-case_body:
-    WHEN when_args then compstmt cases
+  | DO
     {
-      # result = "result = [['when', val[1], val[3]]].concat(val[4]);"
-      result = [[val[0], val[1], val[3]]] + val[4]
+      push_scope :block
+      result = @line
     }
-
-when_args:
-    args
+    opt_block_var compstmt END
     {
-      result = val[0]
+      result = new_iter nil, val[2], val[3]
+      result.line = val[1]
+      pop_scope
     }
-  | args ',' SPLAT arg_value
+
+case_body:
+    WHEN
     {
-      result = val[0]
+      result = @line
     }
-  | SPLAT arg_value
+    args then compstmt cases
     {
-      result = []
+      part = s(:when, val[2], val[4])
+      part.line = val[2].line
+      result = [part]
+      result.push *val[5] if val[5]
     }
 
 cases:
     opt_else
+    {
+      result = [val[0]]
+    }
   | case_body
 
 opt_rescue:
     RESCUE exc_list exc_var then compstmt opt_rescue
     {
-      result = [[val[0], val[1], val[2], val[4]]]
-      result.concat val[5]
+      exc = val[1] || s(:array)
+      exc << new_assign(val[2], s(:gvar, '$!'.intern)) if val[2]
+      result = [s(:resbody, exc, val[4])]
+      result.push val[5].first if val[5]
     }
   |
     {
-      result = []
+      result = nil
     }
 
 exc_list:
     arg_value
+    {
+      result = s(:array, val[0])
+    }
   | mrhs
   | none
 
@@ -1005,20 +1132,26 @@ exc_var:
 opt_ensure:
     ENSURE compstmt
     {
-      result = val[1]
+      result = val[1].nil? ? s(:nil) : val[1]
     }
   | none
-    {
-      result = nil
-    }
 
 literal:
     numeric
+    {
+      result = s(:lit, val[0])
+    }
   | symbol
+    {
+      result = s(:lit, val[0])
+    }
   | dsym
 
 strings:
     string
+    {
+      result = new_str val[0]
+    }
 
 string:
     string1
@@ -1027,40 +1160,42 @@ string:
 string1:
     STRING_BEG string_contents STRING_END
     {
-      result = StringNode.new val[1], val[2]
+      result = val[1]
     }
   | STRING
 
 xstring:
     XSTRING_BEG xstring_contents STRING_END
     {
-      result = XStringNode.new val[0], val[1], val[2]
+      result = new_xstr val[1]
     }
 
 regexp:
     REGEXP_BEG xstring_contents REGEXP_END
     {
-      result = RegexpNode.new val[0], val[1]
+      result = new_regexp val[1]
     }
 
 words:
     WORDS_BEG SPACE STRING_END
     {
-      result = WordsNode.new val[0], [], val[2]
+      result = s(:array)
     }
   | WORDS_BEG word_list STRING_END
     {
-      result = WordsNode.new val[0], val[1], val[2]
+      result = val[1]
     }
 
 word_list:
     none
     {
-      result = []
+      result = s(:array)
     }
   | word_list word SPACE
     {
-      result = val[0].concat([val[1]])
+      part = val[1]
+      part = s(:dstr, "", val[1]) if part[0] == :evstr
+      result = val[0] << part
     }
 
 word:
@@ -1076,75 +1211,95 @@ word:
 awords:
     AWORDS_BEG SPACE STRING_END
     {
-      result = WordsNode.new val[0], [], val[2]
+      result = s(:array)
     }
   | AWORDS_BEG qword_list STRING_END
     {
-      result = WordsNode.new val[0], val[1], val[2]
+      result = val[1]
     }
 
 qword_list:
     none
     {
-      result = []
+      result = s(:array)
     }
   | qword_list STRING_CONTENT SPACE
     {
-      result = val[0].concat([['string_content', val[1]]])
+      result = val[0] << s(:str, val[1])
     }
 
 string_contents:
     none
     {
-      result = []
+      result = nil
     }
   | string_contents string_content
     {
-      result = val[0] << val[1]
+      result = str_append val[0], val[1]
     }
 
 xstring_contents:
     none
     {
-      result = []
+      result = nil
     }
   | xstring_contents string_content
     {
-      result = val[0].concat [val[1]]
+      result = str_append val[0], val[1]
     }
 
 string_content:
     STRING_CONTENT
     {
-      result = ['string_content', val[0]]
+      result = s(:str, val[0])
+    }
+  | STRING_DVAR
+    {
+      result = @string_parse
+      @string_parse = nil
     }
-  | STRING_DVAR string_dvar
+    string_dvar
     {
-      result = ['string_dvar', val[1]]
+      @string_parse = val[1]
+      result = s(:evstr, val[2])
     }
   | STRING_DBEG
     {
       cond_push 0
       cmdarg_push 0
+      result = @string_parse
+      @string_parse = nil
+      @lex_state = :expr_beg
     }
     compstmt '}'
     {
+      @string_parse = val[1]
       cond_lexpop
       cmdarg_lexpop
-      result = ['string_dbegin', val[2]]
+      result = s(:evstr, val[2])
     }
 
 string_dvar:
     GVAR
+    {
+      result = s(:gvar, val[0].intern)
+    }
   | IVAR
+    {
+      result = s(:ivar, val[0].intern)
+    }
   | CVAR
+    {
+      result = s(:cvar, val[0].intern)
+    }
   | backref
 
 
 symbol:
     SYMBOL_BEG sym
     {
-      result = SymbolNode.new val[1]
+      result = val[1].intern
+      @lex_state = :expr_end
     }
   | SYMBOL
 
@@ -1156,80 +1311,72 @@ sym: fname
 dsym:
     SYMBOL_BEG xstring_contents STRING_END
     {
-      result = "result = ['dsym', val[1]];"
+      result = new_dsym val[1]
     }
 
 numeric:
     INTEGER
-    {
-      result = NumericNode.new val[0]
-    }
   | FLOAT
-    {
-      result = NumericNode.new val[0]
-    }
   | '-@NUM' INTEGER =LOWEST
   | '-@NUM' FLOAT   =LOWEST
 
 variable:
     IDENTIFIER
     {
-      result = IdentifierNode.new val[0]
+      result = s(:identifier, val[0].intern)
     }
   | IVAR
     {
-      result = IvarNode.new val[0]
+      result = s(:ivar, val[0].intern)
     }
   | GVAR
     {
-      result = GvarNode.new val[0];
+      result = s(:gvar, val[0].intern)
     }
   | CONSTANT
     {
-      result = ConstantNode.new val[0]
+      result = s(:const, val[0].intern)
     }
   | CVAR
     {
-      result = CvarNode.new val[0]
+      result = s(:cvar, val[0].intern)
     }
   | NIL
     {
-      result = NilNode.new val[0]
-    }
-  | UNDEFINED
-    {
-      result = UndefinedNode.new val[0]
-    }
-  | NULL
-    {
-      result = NullNode.new val[0]
+      result = s(:nil)
     }
   | SELF
     {
-      result = SelfNode.new val[0]
+      result = s(:self)
     }
   | TRUE
     {
-      result = TrueNode.new val[0]
+      result = s(:true)
     }
   | FALSE
     {
-      result = FalseNode.new val[0]
+      result = s(:false)
     }
   | FILE
     {
-      result = FileNode.new val[0]
+      result = s(:str, @file)
     }
   | LINE
     {
-      result = LineNode.new val[0]
+      result = s(:lit, @line)
     }
 
 var_ref:
     variable
+    {
+      result = new_var_ref val[0]
+    }
 
 var_lhs:
     variable
+    {
+      result = new_assignable val[0]
+    }
 
 backref:
     NTH_REF
@@ -1262,59 +1409,63 @@ f_arglist:
 f_args:
     f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
     {
-      result = [val[0], val[2], val[4], val[5]]
+      result = new_args val[0], val[2], val[4], val[5]
     }
   | f_arg ',' f_optarg opt_f_block_arg
     {
-      result = [val[0], val[2], nil, val[3]]
+      result = new_args val[0], val[2], nil, val[3]
     }
   | f_arg ',' f_rest_arg opt_f_block_arg
     {
-      result = [val[0], nil, val[2], val[3]]
+      result = new_args val[0], nil, val[2], val[3]
     }
   | f_arg opt_f_block_arg
     {
-      result = [val[0], nil, nil, val[1]]
+      result = new_args val[0], nil, nil, val[1]
     }
   | f_optarg ',' f_rest_arg opt_f_block_arg
     {
-      rsult = [nil, val[0], val[2], val[3]]
+      result = new_args nil, val[0], val[2], val[3]
     }
   | f_optarg opt_f_block_arg
     {
-      result = [nil, val[0], nil, val[1]]
+      result = new_args nil, val[0], nil, val[1]
     }
   | f_rest_arg opt_f_block_arg
     {
-      result = [nil, nil, val[0], val[1]]
+      result = new_args nil, nil, val[0], val[1]
     }
   | f_block_arg
     {
-      result = [nil, nil, nil, val[0]]
+      result = new_args nil, nil, nil, val[0]
     }
   |
     {
-      result = [nil, nil, nil, nil]
+      result = s(:args)
     }
 
 f_norm_arg:
     CONSTANT
     {
-      result = "this.yyerror('formal argument cannot be a constant');"
+      raise 'formal argument cannot be a constant'
     }
   | IVAR
     {
-      result = "this.yyerror('formal argument cannot be an instance variable');"
+      raise 'formal argument cannot be an instance variable'
     }
   | CVAR
     {
-      result = "this.yyerror('formal argument cannot be a class variable');"
+      raise 'formal argument cannot be a class variable'
     }
   | GVAR
     {
-      result = "this.yyerror('formal argument cannot be a global variable');"
+      raise 'formal argument cannot be a global variable'
     }
   | IDENTIFIER
+    {
+      result = val[0].intern
+      @scope.add_local result
+    }
 
 f_arg:
     f_norm_arg
@@ -1330,13 +1481,13 @@ f_arg:
 f_opt:
     IDENTIFIER '=' arg_value
     {
-      result = [val[0], val[2]]
+      result = new_assign new_assignable(s(:identifier, val[0].intern)), val[2]
     }
 
 f_optarg:
     f_opt
     {
-      result = [val[0]]
+      result = s(:block, val[0])
     }
   | f_optarg ',' f_opt
     {
@@ -1351,11 +1502,11 @@ restarg_mark:
 f_rest_arg:
     restarg_mark IDENTIFIER
     {
-      result = val[1]
+      result = "*#{val[1]}".intern
     }
   | restarg_mark
     {
-      result = val[0]
+      result = :"*"
     }
 
 blkarg_mark:
@@ -1365,7 +1516,7 @@ blkarg_mark:
 f_block_arg:
     blkarg_mark IDENTIFIER
     {
-      result = val[1]
+      result = "&#{val[1]}".intern
     }
 
 opt_f_block_arg:
@@ -1405,11 +1556,11 @@ assoc_list:
 assocs:
     assoc
     {
-      result = [val[0]]
+      result = val[0]
     }
   | assocs ',' assoc
     {
-      result = val[0] << val[2]
+      result = val[0].push *val[2]
     }
 
 assoc:
@@ -1419,7 +1570,7 @@ assoc:
     }
   | LABEL arg_value
     {
-      result = [SymbolNode.new(val[0]), val[1]]
+      result = [s(:lit, val[0].intern), val[1]]
     }
 
 operation:
@@ -1466,9 +1617,4 @@ none_block_pass:
 
 end
 
----- header
-
-require 'opal/lexer'
-require 'opal/nodes'
-
 ---- inner