opal 0.4.4 → 0.5.0

data/lib/opal/nodes/while.rb

@@ -0,0 +1,65 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class WhileNode < Base
+      handle :while
+
+      children :test, :body
+
+      def compile
+        with_temp do |redo_var|
+          test_code = js_truthy(test)
+
+          compiler.in_while do
+            while_loop[:closure] = true if wrap_in_closure?
+            while_loop[:redo_var] = redo_var
+
+            body_code = stmt(body)
+
+            if uses_redo?
+              push "#{redo_var} = false; #{while_open}#{redo_var} || "
+              push test_code
+              push while_close
+            else
+              push while_open, test_code, while_close
+            end
+
+            push "#{redo_var} = false;" if uses_redo?
+            line body_code, "}"
+          end
+        end
+
+        wrap '(function() {', '; return nil; })()' if wrap_in_closure?
+      end
+
+      def while_open
+        "while ("
+      end
+
+      def while_close
+        ") {"
+      end
+
+      def uses_redo?
+        while_loop[:use_redo]
+      end
+
+      def wrap_in_closure?
+        expr? or recv?
+      end
+    end
+
+    class UntilNode < WhileNode
+      handle :until
+
+      def while_open
+        "while (!("
+      end
+
+      def while_close
+        ")) {"
+      end
+    end
+  end
+end

data/lib/opal/nodes/yield.rb

@@ -0,0 +1,84 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class BaseYieldNode < Base
+      def compile_call(children, level)
+        scope.uses_block!
+
+        if yields_single_arg?(children)
+          push expr(children.first)
+          wrap "$opal.$yield1(#{block_name}, ", ')'
+        else
+          push expr(s(:arglist, *children))
+
+          if uses_splat?(children)
+            wrap "$opal.$yieldX(#{block_name}, ", ')'
+          else
+            wrap "$opal.$yieldX(#{block_name}, [", '])'
+          end
+        end
+      end
+
+      def block_name
+        scope.block_name || '$yield'
+      end
+
+      def yields_single_arg?(children)
+        !uses_splat?(children) and children.size == 1
+      end
+
+      def uses_splat?(children)
+        children.any? { |child| child.type == :splat }
+      end
+    end
+
+    class YieldNode < BaseYieldNode
+      handle :yield
+
+      def compile
+        compile_call(children, @level)
+
+        if stmt?
+          wrap 'if (', ' === $breaker) return $breaker.$v'
+        else
+          with_temp do |tmp|
+            wrap "(((#{tmp} = ", ") === $breaker) ? $breaker.$v : #{tmp})"
+          end
+        end
+      end
+
+    end
+
+    # special opal yield assign, for `a = yield(arg1, arg2)` to assign
+    # to a temp value to make yield expr into stmt.
+    #
+    # level will always be stmt as its the reason for this to exist
+    #
+    # s(:yasgn, :a, s(:yield, arg1, arg2))
+    class YasgnNode < BaseYieldNode
+      handle :yasgn
+
+      children :var_name, :yield_args
+
+      def compile
+        compile_call(s(*yield_args[1..-1]), :stmt)
+        wrap "if ((#{var_name} = ", ") === $breaker) return $breaker.$v"
+      end
+    end
+
+    # Created by `#returns()` for when a yield statement should return
+    # it's value (its last in a block etc).
+    class ReturnableYieldNode < BaseYieldNode
+      handle :returnable_yield
+
+      def compile
+        compile_call children, @level
+
+        with_temp do |tmp|
+          wrap "return #{tmp} = ", ", #{tmp} === $breaker ? #{tmp} : #{tmp}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/parser.rb

@@ -1,2298 +1,423 @@
-require 'opal/lexer'
-require 'opal/grammar'
-require 'opal/target_scope'
-require 'opal/version'
+require 'opal/parser/sexp'
+require 'opal/parser/lexer'
+require 'opal/parser/grammar'
+require 'opal/parser/parser_scope'
 
 module Opal
-  class Parser
+  class Parser < Racc::Parser
 
-    # A fragment holds a string of generated javascript that will be written
-    # to the destination. It also keeps hold of the original sexp from which
-    # it was generated. Using this sexp, when writing fragments in order, a
-    # mapping can be created of the original location => target location,
-    # aka, source-maps!
-    class Fragment
-      # String of javascript this fragment holds
-      attr_reader :code
+    attr_reader :lexer, :file, :scope
 
-      def initialize(code, sexp = nil)
-        @code = code.to_s
-        @sexp = sexp
-      end
-
-      # In debug mode we may wish to include the original line as a comment
-      def to_code
-        if @sexp
-          "/*:#{@sexp.line}*/#{@code}"
-        else
-          @code
-        end
-      end
-
-      # inspect the contents of this fragment, f("fooo")
-      def inspect
-        "f(#{@code.inspect})"
-      end
-
-      def line
-        @sexp.line if @sexp
-      end
-    end
-
-    # Generated code gets indented with two spaces on each scope
-    INDENT = '  '
-
-    # Expressions are handled at diffferent levels. Some sexps
-    # need to know the js expression they are generating into.
-    LEVEL = [:stmt, :stmt_closure, :list, :expr, :recv]
-
-    # All compare method nodes - used to optimize performance of
-    # math comparisons
-    COMPARE = %w[< > <= >=]
-
-    # Reserved javascript keywords - we cannot create variables with the
-    # same name
-    RESERVED = %w(
-      break case catch continue debugger default delete do else finally for
-      function if in instanceof new return switch this throw try typeof var let
-      void while with class enum export extends import super true false native
-      const static
-    )
-
-    # Statements which should not have ';' added to them.
-    STATEMENTS = [:xstr, :dxstr]
-
-    # Final generated javascript for this parser
-    attr_reader :result
-
-    # generated fragments as an array
-    attr_reader :fragments
-
-    # Parse some ruby code to a string.
-    #
-    #     Opal::Parser.new.parse("1 + 2")
-    #     # => "(function() {....})()"
-    def parse(source, options = {})
-      @sexp = Grammar.new.parse(source, options[:file])
-      @line     = 1
-      @indent   = ''
-      @unique   = 0
-
-      @helpers  = {
-        :breaker  => true,
-        :slice    => true
-      }
-
-      # options
-      @file                     =  options[:file] || '(file)'
-      @source_file              =  options[:source_file] || @file
-      @method_missing           = (options[:method_missing] != false)
-      @arity_check              =  options[:arity_check]
-      @const_missing            = (options[:const_missing] != false)
-      @irb_vars                 = (options[:irb] == true)
-
-      @method_calls = {}
-
-      @fragments = self.top(@sexp).flatten
-
-      @fragments.unshift f(version_comment)
-
-      @result = @fragments.map(&:code).join('')
-    end
-
-    # Always at top of generated file to show current opal version
-    def version_comment
-      "/* Generated by Opal #{Opal::VERSION} */\n"
-    end
-
-    def source_map
-      Opal::SourceMap.new(@fragments, '(file)')
-    end
-
-    def extract_parser_options(content)
-      result = {}
-
-      if /^#\ opal\:(.*)/ =~ content
-        $~[1].split(',').map(&:strip).each do |opt|
-          next if opt == ""
-          opt = opt.gsub('-', '_')
-
-          if opt =~ /no_/
-            result[opt.sub(/no_/, '').to_sym] = false
-          else
-            result[opt.to_sym] = true
-          end
-        end
-      end
-
-      result
-    end
-
-    # This is called when a parsing/processing error occurs. This
-    # method simply appends the filename and curent line number onto
-    # the message and raises it.
-    #
-    #     parser.error "bad variable name"
-    #     # => raise "bad variable name :foo.rb:26"
-    #
-    # @param [String] msg error message to raise
-    def error(msg)
-      raise SyntaxError, "#{msg} :#{@file}:#{@line}"
-    end
-
-    # This is called when a parsing/processing warning occurs. This
-    # method simply appends the filename and curent line number onto
-    # the message and issues a warning.
-    #
-    # @param [String] msg warning message to raise
-    def warning(msg)
-      warn "#{msg} :#{@file}:#{@line}"
-    end
-
-    # Instances of `Scope` can use this to determine the current
-    # scope indent. The indent is used to keep generated code easily
-    # readable.
-    #
-    # @return [String]
-    def parser_indent
-      @indent
-    end
-
-    # Create a new sexp using the given parts. Even though this just
-    # returns an array, it must be used incase the internal structure
-    # of sexps does change.
-    #
-    #     s(:str, "hello there")
-    #     # => [:str, "hello there"]
-    #
-    # @result [Array]
-    def s(*parts)
-      sexp = Array.new(parts)
-      sexp.line = @line
-      sexp
-    end
-
-    # @param [String] code the string of code
-    # @return [Fragment]
-    def f(code, sexp = nil)
-      Fragment.new(code, sexp)
-    end
-
-    alias_method :fragment, :f
-
-    # Converts a ruby method name into its javascript equivalent for
-    # a method/function call. All ruby method names get prefixed with
-    # a '$', and if the name is a valid javascript identifier, it will
-    # have a '.' prefix (for dot-calling), otherwise it will be
-    # wrapped in brackets to use reference notation calling.
-    #
-    #     mid_to_jsid('foo')      # => ".$foo"
-    #     mid_to_jsid('class')    # => ".$class"
-    #     mid_to_jsid('==')       # => "['$==']"
-    #     mid_to_jsid('name=')    # => "['$name=']"
-    #
-    # @param [String] mid ruby method id
-    # @return [String]
-    def mid_to_jsid(mid)
-      if /\=|\+|\-|\*|\/|\!|\?|\<|\>|\&|\||\^|\%|\~|\[/ =~ mid.to_s
-        "['$#{mid}']"
-      else
-        '.$' + mid
-      end
-    end
-
-    # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
-    # are valid in javascript. A $ suffix is added to non-valid names.
-    def lvar_to_js(var)
-      var = "#{var}$" if RESERVED.include? var.to_s
-      var.to_sym
-    end
-
-    # Used to generate a unique id name per file. These are used
-    # mainly to name method bodies for methods that use blocks.
-    #
-    # @return [String]
-    def unique_temp
-      "TMP_#{@unique += 1}"
-    end
-
-    # Generate the code for the top level sexp, i.e. the root sexp
-    # for a file. This is used directly by `#parse`. It pushes a
-    # ":top" scope onto the stack and handles the passed in sexp.
-    # The result is a string of javascript representing the sexp.
-    #
-    # @param [Array] sexp the sexp to process
-    # @return [String]
-    def top(sexp, options = {})
-      code, vars = nil, nil
-
-      # empty file = nil as our top sexp
-      sexp = s(:nil) unless sexp
-
-      in_scope(:top) do
-        indent {
-          scope = s(:scope, sexp)
-          scope.line = sexp.line
-
-          code = process(scope, :stmt)
-          code = [code] unless code.is_a? Array
-          code.unshift f(@indent, sexp)
-        }
-
-        @scope.add_temp "self = $opal.top"
-        @scope.add_temp "$scope = $opal"
-        @scope.add_temp "nil = $opal.nil"
-        @scope.add_temp "def = $opal.Object._proto" if @scope.defines_defn
-        @helpers.keys.each { |h| @scope.add_temp "$#{h} = $opal.#{h}" }
-
-        vars = [f(INDENT, sexp), @scope.to_vars, f("\n", sexp)]
-
-        if @irb_vars
-          code.unshift f("if (!$opal.irb_vars) { $opal.irb_vars = {}; }\n", sexp)
-        end
-      end
-
-      if @method_missing
-        stubs = f("\n#{INDENT}$opal.add_stubs([" + @method_calls.keys.map { |k| "'$#{k}'" }.join(", ") + "]);\n", sexp)
-      else
-        stubs = []
-      end
-
-      [f("(function($opal) {\n", sexp), vars, stubs, code, f("\n})(Opal);\n", sexp)]
-    end
-
-    # Every time the parser enters a new scope, this is called with
-    # the scope type as an argument. Valid types are `:top` for the
-    # top level/file scope; `:class`, `:module` and `:sclass` for the
-    # obvious ruby classes/modules; `:def` and `:iter` for methods
-    # and blocks respectively.
-    #
-    # This method just pushes a new instance of `Opal::Scope` onto the
-    # stack, sets the new scope as the `@scope` variable, and yields
-    # the given block. Once the block returns, the old scope is put
-    # back on top of the stack.
-    #
-    #     in_scope(:class) do
-    #       # generate class body in here
-    #       body = "..."
-    #     end
-    #
-    #     # use body result..
-    #
-    # @param [Symbol] type the type of scope
-    # @return [nil]
-    def in_scope(type)
-      return unless block_given?
-
-      parent = @scope
-      @scope = TargetScope.new(type, self).tap { |s| s.parent = parent }
-      yield @scope
-
-      @scope = parent
-    end
-
-    # To keep code blocks nicely indented, this will yield a block after
-    # adding an extra layer of indent, and then returning the resulting
-    # code after reverting the indent.
-    #
-    #   indented_code = indent do
-    #     "foo"
-    #   end
-    #
-    # @result [String]
-    def indent(&block)
-      indent = @indent
-      @indent += INDENT
-      @space = "\n#@indent"
-      res = yield
-      @indent = indent
-      @space = "\n#@indent"
-      res
-    end
-
-    # Temporary varibales will be needed from time to time in the
-    # generated code, and this method will assign (or reuse) on
-    # while the block is yielding, and queue it back up once it is
-    # finished. Variables are queued once finished with to save the
-    # numbers of variables needed at runtime.
-    #
-    #     with_temp do |tmp|
-    #       "tmp = 'value';"
-    #     end
-    #
-    # @return [String] generated code withing block
-    def with_temp(&block)
-      tmp = @scope.new_temp
-      res = yield tmp
-      @scope.queue_temp tmp
-      res
-    end
-
-    # Used when we enter a while statement. This pushes onto the current
-    # scope's while stack so we know how to handle break, next etc.
-    #
-    # Usage:
-    #
-    #     in_while do
-    #       # generate while body here.
-    #     end
-    def in_while
-      return unless block_given?
-      @while_loop = @scope.push_while
-      result = yield
-      @scope.pop_while
-
-      result
-    end
-
-    def in_case
-      return unless block_given?
-      old = @case_stmt
-      @case_stmt = {}
-      yield
-      @case_stmt = old
-    end
-
-    # Returns true if the parser is curently handling a while sexp,
-    # false otherwise.
-    #
-    # @return [Boolean]
-    def in_while?
-      @scope.in_while?
-    end
-
-    # Processes a given sexp. This will send a method to the receiver
-    # of the format "process_<sexp_name>". Any sexp handler should
-    # return a string of content.
-    #
-    # For example, calling `process` with `s(:sym, 42)` will call the
-    # method `#process_lit`. If a method with that name cannot be
-    # found, then an error is raised.
-    #
-    #     process(s(:int, 42), :stmt)
-    #     # => "42"
-    #
-    # @param [Array] sexp the sexp to process
-    # @param [Symbol] level the level to process (see `LEVEL`)
-    # @return [String]
-    def process(sexp, level = :expr)
-      type = sexp.shift
-      meth = "process_#{type}"
-      raise "Unsupported sexp: #{type}" unless respond_to? meth
-
-      @line = sexp.line
-
-      __send__(meth, sexp, level)
-    end
-
-    # The last sexps in method bodies, for example, need to be returned
-    # in the compiled javascript. Due to syntax differences between
-    # javascript any ruby, some sexps need to be handled specially. For
-    # example, `if` statemented cannot be returned in javascript, so
-    # instead the "truthy" and "falsy" parts of the if statement both
-    # need to be returned instead.
-    #
-    # Sexps that need to be returned are passed to this method, and the
-    # alterned/new sexps are returned and should be used instead. Most
-    # sexps can just be added into a s(:return) sexp, so that is the
-    # default action if no special case is required.
-    #
-    #     sexp = s(:str, "hey")
-    #     parser.returns(sexp)
-    #     # => s(:js_return, s(:str, "hey"))
-    #
-    # `s(:js_return)` is just a special sexp used to return the result
-    # of processing its arguments.
-    #
-    # @param [Array] sexp the sexp to alter
-    # @return [Array] altered sexp
-    def returns(sexp)
-      return returns s(:nil) unless sexp
-
-      case sexp.first
-      when :break, :next
-        sexp
-      when :yield
-        sexp[0] = :returnable_yield
-        sexp
-      when :scope
-        sexp[1] = returns sexp[1]
-        sexp
-      when :block
-        if sexp.length > 1
-          sexp[-1] = returns sexp[-1]
-        else
-          sexp << returns(s(:nil))
-        end
-        sexp
-      when :when
-        sexp[2] = returns(sexp[2])
-        sexp
-      when :rescue
-        sexp[1] = returns sexp[1]
-
-        if sexp[2] and sexp[2][0] == :resbody and sexp[2][2]
-          sexp[2][2] = returns sexp[2][2]
-        end
-        sexp
-      when :ensure
-        sexp[1] = returns sexp[1]
-        sexp
-      when :while
-        # sexp[2] = returns(sexp[2])
-        sexp
-      when :return
-        sexp
-      when :xstr
-        sexp[1] = "return #{sexp[1]};" unless /return|;/ =~ sexp[1]
-        sexp
-      when :dxstr
-        sexp[1] = "return #{sexp[1]}" unless /return|;|\n/ =~ sexp[1]
-        sexp
-      when :if
-        sexp[2] = returns(sexp[2] || s(:nil))
-        sexp[3] = returns(sexp[3] || s(:nil))
-        sexp
-      else
-        s(:js_return, sexp).tap { |s|
-          s.line = sexp.line
-        }
-      end
-    end
-
-    # Returns true if the given sexp is an expression. All expressions
-    # will get ';' appended to their result, except for the statement
-    # sexps. See `STATEMENTS` for a list of sexp names that are
-    # statements.
-    #
-    # @param [Array] sexp the sexp to check
-    # @return [Boolean]
-    def expression?(sexp)
-      !STATEMENTS.include?(sexp.first)
-    end
-
-    # More than one expression in a row will be grouped by the grammar
-    # into a block sexp. A block sexp just holds any number of other
-    # sexps.
-    #
-    #     s(:block, s(:str, "hey"), s(:int, 42))
-    #
-    # A block can actually be empty. As opal requires real values to
-    # be returned (to appease javascript values), a nil sexp
-    # s(:nil) will be generated if the block is empty.
-    #
-    # @return [String]
-    def process_block(sexp, level)
-      return process s(:nil) if sexp.empty?
-
-      result = []
-      join = (@scope.class_scope? ? "\n\n#@indent" : "\n#@indent")
-
-      sexp.each do |stmt|
-        result << f(join, sexp) unless result.empty?
-
-        # find any inline yield statements
-        if yasgn = find_inline_yield(stmt)
-          result << process(yasgn, level) << f(";", yasgn)
-        end
-
-        expr = expression?(stmt) and LEVEL.index(level) < LEVEL.index(:list)
-
-        result << process(stmt, level)
-        result << f(";", stmt) if expr
-      end
-
-      result
-    end
-
-    # When a block sexp gets generated, any inline yields (i.e. yield
-    # statements that are not direct members of the block) need to be
-    # generated as a top level member. This is because if a yield
-    # is returned by a break statement, then the method must return.
-    #
-    # As inline expressions in javascript cannot return, the block
-    # must be rewritten.
-    #
-    # For example, a yield inside an array:
-    #
-    #     [1, 2, 3, yield(4)]
-    #
-    # Must be rewitten into:
-    #
-    #     tmp = yield 4
-    #     [1, 2, 3, tmp]
-    #
-    # This rewriting happens on sexps directly.
-    #
-    # @param [Sexp] stmt sexps to (maybe) rewrite
-    # @return [Sexp]
-    def find_inline_yield(stmt)
-      found = nil
-      case stmt.first
-      when :js_return
-        if found = find_inline_yield(stmt[1])
-          found = found[2]
-        end
-      when :array
-        stmt[1..-1].each_with_index do |el, idx|
-          if el.first == :yield
-            found = el
-            stmt[idx+1] = s(:js_tmp, '$yielded')
-          end
-        end
-      when :call
-        arglist = stmt[3]
-        arglist[1..-1].each_with_index do |el, idx|
-          if el.first == :yield
-            found = el
-            arglist[idx+1] = s(:js_tmp, '$yielded')
-          end
-        end
-      end
-
-      if found
-        @scope.add_temp '$yielded' unless @scope.has_temp? '$yielded'
-        s(:yasgn, '$yielded', found)
-      end
-    end
-
-    def process_scope(sexp, level)
-      stmt = sexp[0] || s(:nil)
-      stmt = returns stmt unless @scope.class_scope?
-
-      process stmt, :stmt
-    end
-
-    # s(:js_return, sexp)
-    def process_js_return(sexp, level)
-      [f("return ", sexp), process(sexp[0])]
-    end
-
-    # s(:js_tmp, str)
-    def process_js_tmp(sexp, level)
-      f(sexp[0].to_s, sexp)
-    end
-
-    def js_block_given(sexp, level)
-      @scope.uses_block!
-      if @scope.block_name
-        f("(#{@scope.block_name} !== nil)", sexp)
-      elsif scope = @scope.find_parent_def and scope.block_name
-        f("(#{scope.block_name} !== nil)", sexp)
-      else
-        f("false", sexp)
-      end
-    end
-
-    def handle_block_given(sexp, reverse = false)
-      @scope.uses_block!
-      name = @scope.block_name
-
-      f((reverse ? "#{ name } === nil" : "#{ name } !== nil"), sexp)
-    end
-
-    def process_sym(sexp, level)
-      f(sexp[0].to_s.inspect, sexp)
-    end
-
-    # Process integers. Wrap in parens if a receiver of method call
-    def process_int(sexp, level)
-      f((level == :recv ? "(#{sexp[0]})" : sexp[0].to_s), sexp)
-    end
-
-    # Floats generated just like integers
-    alias_method :process_float, :process_int
-
-    # Regexp literals. Convert to empty js regexp if empty (not compatible)
-    def process_regexp(sexp, level)
-      val = sexp[0]
-      f((val == // ? /^/.inspect : val.inspect), sexp)
-    end
-
-    # Dynamic regexps with interpolation
-    # s(:dregx, parts...) => new Regexp("...")
-    def process_dregx(sexp, level)
-      result = []
-
-      sexp.each do |part|
-        result << f(" + ", sexp) unless result.empty?
-
-        if String === part
-          result << f(part.inspect, sexp)
-        elsif part[0] == :str
-          result << process(part)
-        else
-          result << process(part[1])
-        end
-      end
-
-      [f("(new RegExp(", sexp), result, f("))", sexp)]
-    end
-
-    # Exclusive range, uses opal __range helper.
-    # s(:dot3, start, end) => __range(start, end, false)
-    def process_dot2(sexp, level)
-      @helpers[:range] = true
-
-      [f("$range(", sexp), process(sexp[0]), f(", ", sexp), process(sexp[1]), f(", false)", sexp)]
-    end
-
-    # Inclusive range, uses __range helper
-    # s(:dot3, start, end) => __range(start, end, true)
-    def process_dot3(sexp, level)
-      @helpers[:range] = true
-
-      [f("$range(", sexp), process(sexp[0]), f(", ", sexp), process(sexp[1]), f(", true)", sexp)]
-    end
-
-    # Simple strings, no interpolation.
-    # s(:str, "string") => "string"
-    def process_str(sexp, level)
-      f sexp[0].inspect, sexp
-    end
-
-    # defined?(x) => various
-    def process_defined(sexp, level)
-      part = sexp[0]
-      case part[0]
-      when :self
-        f("'self'", sexp)
-      when :nil
-        f("'nil'", sexp)
-      when :true
-        f("'true'", sexp)
-      when :false
-        f("'false'", sexp)
-      when :call
-        mid = mid_to_jsid part[2].to_s
-        recv = part[1] ? process(part[1]) : f(current_self, sexp)
-        [f("(", sexp), recv, f("#{mid} ? 'method' : nil)", sexp)]
-      when :xstr, :dxstr
-        [f("(typeof(", sexp), process(part), f(") !== 'undefined')", sexp)]
-      when :const
-        f("($scope.#{part[1].to_s} != null)", sexp)
-      when :cvar
-        f("($opal.cvars[#{part[1].to_s.inspect}] != null ? 'class-variable' : nil)", sexp)
-      when :colon2
-        f("false", sexp)
-      when :colon3
-        f("($opal.Object._scope.#{sexp[0][1]} == null ? nil : 'constant')", sexp)
-      when :ivar
-        ivar_name = part[1].to_s[1..-1]
-        with_temp do |t|
-          f("((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)", sexp)
-        end
-      when :lvar
-        f("local-variable", sexp)
-      else
-        raise "bad defined? part: #{part[0]}"
-      end
-    end
-
-    # not keyword or '!' operand
-    # s(:not, value) => (tmp = value, (tmp === nil || tmp === false))
-    def process_not(sexp, level)
-      with_temp do |tmp|
-        expr = sexp[0]
-        [f("(#{tmp} = ", sexp), process(expr), f(", (#{tmp} === nil || #{tmp} === false))", sexp)]
-      end
-    end
-
-    # A block pass '&foo' syntax
-    # s(:block_pass, value) => value.$to_proc()
-    def process_block_pass(exp, level)
-      process s(:call, exp[0], :to_proc, s(:arglist))
-    end
-
-    # A block/iter with embeded call. Compiles into function
-    # s(:iter, call, block_args [, body) => (function() { ... })
-    def process_iter(sexp, level)
-      call, args, body = sexp
-
-      body ||= s(:nil)
-      body = returns body
-      code = []
-      params = nil
-      scope_name = nil
-      identity = nil
-      to_vars = nil
-
-      args = nil if Fixnum === args # argh
-      args ||= s(:masgn, s(:array))
-      args = args.first == :lasgn ? s(:array, args) : args[1]
-
-      # opt args are last, if present, and are a [:block]
-      if args.last.is_a?(Array) and args.last[0] == :block
-        opt_args = args.pop
-        opt_args.shift
-      end
-
-      if args.last.is_a?(Array) and args.last[0] == :block_pass
-        block_arg = args.pop
-        block_arg = block_arg[1][1].to_sym
-      end
-
-      if args.last.is_a?(Array) and args.last[0] == :splat
-        splat = args.last[1][1]
-        args.pop
-        len = args.length
-      end
-
-      indent do
-        in_scope(:iter) do
-          identity = @scope.identify!
-          @scope.add_temp "#{current_self} = #{identity}._s || this"
-
-          args[1..-1].each do |arg|
-            arg = arg[1]
-            arg = "#{arg}$" if RESERVED.include? arg.to_s
-
-            if opt_args and current_opt = opt_args.find { |s| s[1] == arg.to_sym }
-              code << [f("if (#{arg} == null) #{arg} = ", sexp), process(current_opt[2]), f(";\n", sexp)]
-            else
-              code << f("if (#{arg} == null) #{arg} = nil;\n", sexp)
-            end
-          end
-
-          params = js_block_args(args[1..-1])
-
-          if splat
-            @scope.add_arg splat
-            params << splat
-            code << f("#{splat} = $slice.call(arguments, #{len - 1});", sexp)
-          end
-
-          if block_arg
-            @scope.block_name = block_arg
-            @scope.add_temp block_arg
-            scope_name = @scope.identify!
-
-            blk = []
-            blk << f("\n#@indent#{block_arg} = #{scope_name}._p || nil, #{scope_name}.p = null;\n#@indent", sexp)
-
-            code.unshift blk
-          end
-
-          code << f("\n#@indent", sexp)
-          code << process(body, :stmt)
-
-          if @scope.defines_defn
-            @scope.add_temp "def = ((#{current_self}._isClass) ? #{current_self}._proto : #{current_self})"
-          end
-
-          to_vars = [f("\n#@indent", sexp), @scope.to_vars, f("\n#@indent", sexp)]
-        end
-      end
-
-      itercode = [f("function(#{params.join ', '}) {\n", sexp), to_vars, code, f("\n#@indent}", sexp)]
-
-      itercode.unshift f("(#{identity} = ", sexp)
-      itercode << f(", #{identity}._s = #{current_self}, #{identity})", sexp)
-
-      call << itercode
-      process call, level
-    end
-
-    # Maps block args into array of jsid. Adds $ suffix to invalid js
-    # identifiers.
-    #
-    # s(:args, parts...) => ["a", "b", "break$"]
-    def js_block_args(sexp)
-      sexp.map do |arg|
-        @scope.add_arg lvar_to_js(arg[1])
-      end
-    end
-
-    ##
-    # recv.mid = rhs
-    #
-    # s(recv, :mid=, s(:arglist, rhs))
-    def process_attrasgn(exp, level)
-      recv, mid, arglist = exp
-      process s(:call, recv, mid, arglist), level
-    end
-
-    # s(:call, recv, :mid, s(:arglist))
-    # s(:call, nil, :mid, s(:arglist))
-    def process_call(sexp, level)
-      recv, meth, arglist, iter = sexp
-      mid = mid_to_jsid meth.to_s
-
-      @method_calls[meth.to_sym] = true
-
-      # we are trying to access a lvar in irb mode
-      if @irb_vars and @scope.top? and arglist == s(:arglist) and recv == nil
-        return with_temp { |t|
-          lvar = meth.intern
-          lvar = "#{lvar}$" if RESERVED.include? lvar
-          call = s(:call, s(:self), meth.intern, s(:arglist))
-          [f("((#{t} = $opal.irb_vars.#{lvar}) == null ? ", sexp), process(call), f(" : #{t})", sexp)]
-        }
-      end
-
-      case meth
-      when :block_given?
-        return js_block_given(sexp, level)
-      end
-
-      splat = arglist[1..-1].any? { |a| a.first == :splat }
-
-      if Array === arglist.last and arglist.last.first == :block_pass
-        block = process(arglist.pop)
-      elsif iter
-        block = iter
-      end
-
-      recv ||= s(:self)
-
-      if block
-        tmpfunc = @scope.new_temp
-      end
-
-      tmprecv = @scope.new_temp if splat || tmpfunc
-      args      = ""
-
-      recv_code = process recv, :recv
-
-      call_recv = s(:js_tmp, tmprecv || recv_code)
-      arglist.insert 1, call_recv if tmpfunc and !splat
-      args = process arglist
-
-      dispatch = if tmprecv
-        [f("(#{tmprecv} = "), recv_code, f(")#{mid}")]
-      else
-        [recv_code, f(mid)]
-      end
-
-      if tmpfunc
-        dispatch.unshift f("(#{tmpfunc} = ")
-        dispatch << f(", #{tmpfunc}._p = ")
-        dispatch << block
-        dispatch << f(", #{tmpfunc})")
-      end
-
-      result = if splat
-        [dispatch, f(".apply("), (tmprecv ? f(tmprecv) : recv_code),
-         f(", "), args, f(")")]
-      elsif tmpfunc
-        [dispatch, f(".call("), args, f(")")]
-      else
-        [dispatch, f("("), args, f(")")]
-      end
-
-      @scope.queue_temp tmpfunc if tmpfunc
-      result
-    end
-
-    # s(:arglist, [arg [, arg ..]])
-    def process_arglist(sexp, level)
-      code, work = [], []
-
-      sexp.each do |current|
-        splat = current.first == :splat
-        arg   = process current
-
-        if splat
-          if work.empty?
-            if code.empty?
-              code << f("[].concat(", sexp)
-              code << arg
-              code << f(")")
-            else
-              code += ".concat(#{arg})"
-            end
-          else
-            if code.empty?
-              code << [f("["), work, f("]")]
-            else
-              code << [f(".concat(["), work, f("])")]
-            end
-
-            code << [f(".concat("), arg, f(")")]
-          end
-
-          work = []
-        else
-          work << f(", ") unless work.empty?
-          work << arg
-        end
-      end
-
-      unless work.empty?
-        join = work
-
-        if code.empty?
-          code = join
-        else
-          code << f(".concat(") << join << f(")")
-        end
-      end
-
-      code
-    end
-
-    # s(:splat, sexp)
-    def process_splat(sexp, level)
-      if sexp.first == [:nil]
-        [f("[]")]
-      elsif sexp.first.first == :sym
-        [f("["), process(sexp[0]), f("]")]
-      else
-        process sexp.first, :recv
-      end
-    end
-
-    # s(:class, cid, super, body)
-    def process_class(sexp, level)
-      cid, sup, body = sexp
-
-      body[1] = s(:nil) unless body[1]
-
-      code = []
-      @helpers[:klass] = true
-
-      if Symbol === cid or String === cid
-        base = process s(:self)
-        name = cid.to_s
-      elsif cid[0] == :colon2
-        base = process(cid[1])
-        name = cid[2].to_s
-      elsif cid[0] == :colon3
-        base = process(s(:js_tmp, '$opal.Object'))
-        name = cid[1].to_s
-      else
-        raise "Bad receiver in class"
-      end
-
-      sup = sup ? process(sup) : process(s(:js_tmp, 'null'))
-
-      indent do
-        in_scope(:class) do
-          @scope.name = name
-          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "$scope = #{name}._scope"
-
-          if Array === body.last
-            # A single statement will need a block
-            needs_block = body.last.first != :block
-            body.last.first == :block
-            last_body_statement = needs_block ? body.last : body.last.last
-
-            if last_body_statement and Array === last_body_statement
-              if [:defn, :defs].include? last_body_statement.first
-                body[-1] = s(:block, body[-1]) if needs_block
-                body.last << s(:nil)
-              end
-            end
-          end
-
-          body = process(returns(body), :stmt)
-          code << f("\n")
-          code << @scope.to_donate_methods
-
-          code << f(@indent)
-          code << @scope.to_vars
-          code << f("\n\n#@indent")
-          code << body
-        end
-      end
-
-      spacer  = "\n#{@indent}#{INDENT}"
-      cls     = "function #{name}() {};"
-      boot    = "#{name} = $klass($base, $super, #{name.inspect}, #{name});"
-
-      [f("(function($base, $super){#{spacer}#{cls}#{spacer}#{boot}\n", sexp),
-       code, f("\n#@indent})", sexp), f("(", sexp), base, f(", ", sexp), sup, f(")", sexp)]
-    end
-
-    # Singleton class syntax. Runs body in context of singleton_class.
-    # s(:sclass, recv, body) => (function() { ... }).call(recv.$singleton_class())
-    def process_sclass(sexp, level)
-      recv, body, code = sexp[0], sexp[1], []
-
-      in_scope(:sclass) do
-        @scope.add_temp "$scope = #{current_self}._scope"
-        @scope.add_temp "def = #{current_self}._proto"
-
-        code << @scope.to_vars << process(body, :stmt)
-      end
-
-      [f("(function(){"), code, f("}).call("), process(recv, :recv), f(".$singleton_class())")]
-    end
-
-    # s(:module, cid, body)
-    def process_module(sexp, level)
-      cid, body = sexp
-      code = []
-      @helpers[:module] = true
-
-      if Symbol === cid or String === cid
-        base = process(s(:self))
-        name = cid.to_s
-      elsif cid[0] == :colon2
-        base = process(cid[1])
-        name = cid[2].to_s
-      elsif cid[0] == :colon3
-        base = f('$opal.Object', sexp)
-        name = cid[1].to_s
-      else
-        raise "Bad receiver in class"
-      end
-
-      indent do
-        in_scope(:module) do
-          @scope.name = name
-          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "$scope = #{name}._scope"
-          body = process body, :stmt
-
-          code << f(@indent)
-          code << @scope.to_vars
-          code << f("\n\n#@indent")
-          code << body
-          code << f("\n#@ident")
-          code << @scope.to_donate_methods
-        end
-      end
-
-      spacer  = "\n#{@indent}#{INDENT}"
-      cls     = "function #{name}() {};"
-      boot    = "#{name} = $module($base, #{name.inspect}, #{name});"
-
-      code.unshift f("(function($base){#{spacer}#{cls}#{spacer}#{boot}\n", sexp)
-      code << f("\n#@indent})(")
-      code << base
-      code << f(")")
-
-      code
-    end
-
-    # undef :foo
-    # => delete MyClass.prototype.$foo
-    # FIXME: we should be setting method to a stub method here
-    def process_undef(sexp, level)
-      f("delete #{ @scope.proto }#{ mid_to_jsid sexp[0][1].to_s }", sexp)
-    end
-
-    # s(:defn, mid, s(:args), s(:scope))
-    def process_defn(sexp, level)
-      mid, args, stmts = sexp
-
-      js_def nil, mid, args, stmts, sexp.line, sexp.end_line, sexp
-    end
-
-    # s(:defs, recv, mid, s(:args), s(:scope))
-    def process_defs(sexp, level)
-      recv, mid, args, stmts = sexp
-
-      js_def recv, mid, args, stmts, sexp.line, sexp.end_line, sexp
-    end
-
-    def js_def(recvr, mid, args, stmts, line, end_line, sexp)
-      jsid = mid_to_jsid mid.to_s
-
-      if recvr
-        @scope.defines_defs = true
-        smethod = true if @scope.class_scope? && recvr.first == :self
-        recv = process(recvr)
-      else
-        @scope.defines_defn = true
-        recv = current_self
-      end
-
-      code = []
-      params = nil
-      scope_name = nil
-      uses_super = nil
-      uses_splat = nil
-
-      # opt args if last arg is sexp
-      opt = args.pop if Array === args.last
-
-      argc = args.length - 1
-
-      # block name &block
-      if args.last.to_s.start_with? '&'
-        block_name = args.pop.to_s[1..-1].to_sym
-        argc -= 1
-      end
-
-      # splat args *splat
-      if args.last.to_s.start_with? '*'
-        uses_splat = true
-        if args.last == :*
-          argc -= 1
-        else
-          splat = args[-1].to_s[1..-1].to_sym
-          args[-1] = splat
-          argc -= 1
-        end
-      end
-
-      if @arity_check
-        arity_code = arity_check(args, opt, uses_splat, block_name, mid) + "\n#{INDENT}"
-      end
-
-      indent do
-        in_scope(:def) do
-          @scope.mid  = mid
-          @scope.defs = true if recvr
-
-          if block_name
-            @scope.uses_block!
-            @scope.add_arg block_name
-          end
-
-          yielder = block_name || '$yield'
-          @scope.block_name = yielder
-
-          params = process args
-          stmt_code = [f("\n#@indent"), process(stmts, :stmt)]
-
-          opt[1..-1].each do |o|
-            next if o[2][2] == :undefined
-            code << f("if (#{o[1]} == null) {\n#{@indent + INDENT}", o)
-            code << process(o)
-            code << f("\n#{@indent}}", o)
-          end if opt
-
-          code << f("#{splat} = $slice.call(arguments, #{argc});", sexp) if splat
-
-          scope_name = @scope.identity
-
-          if @scope.uses_block?
-            @scope.add_temp "$iter = #{scope_name}._p"
-            @scope.add_temp "#{yielder} = $iter || nil"
-
-            code.unshift f("#{scope_name}._p = null;", sexp)
-          end
-
-          code.push(*stmt_code)
-
-          uses_super = @scope.uses_super
-
-          code = [f("#{arity_code}#@indent", sexp), @scope.to_vars, code]
-
-          if @scope.uses_zuper
-            code.unshift f("var $zuper = $slice.call(arguments, 0);", sexp)
-          end
-
-          if @scope.catch_return
-            code.unshift f("try {\n", sexp)
-            code.push f("\n} catch($returner) { if ($returner === $opal.returner) { return $returner.$v; } throw $returner; }", sexp)
-          end
-        end
-      end
-
-      result = [f("#{"#{scope_name} = " if scope_name}function(", sexp)]
-      result.push(*params)
-      result << f(") {\n", sexp)
-      result.push(*code)
-      result << f("\n#@indent}", sexp)
-
-      if recvr
-        if smethod
-          [f("#{@scope.name}.constructor.prototype['$#{mid}'] = ", sexp), result]
-        else
-          [recv, f("#{jsid} = ", sexp), result]
-        end
-      elsif @scope.class? and @scope.name == 'Object'
-        [f("#{current_self}._defn('$#{mid}', ", sexp), result, f(")", sexp)]
-      elsif @scope.class_scope?
-        @scope.methods << "$#{mid}"
-        if uses_super
-          @scope.add_temp uses_super
-          uses_super = "#{uses_super} = #{@scope.proto}#{jsid};\n#@indent"
-        end
-
-        [f("#{uses_super}#{@scope.proto}#{jsid} = ", sexp), result]
-      else # :top, :iter
-        [f("def#{jsid} = ", sexp), result]
-      end
-    end
-
-    ##
-    # Returns code used in debug mode to check arity of method call
-    def arity_check(args, opt, splat, block_name, mid)
-      meth = mid.to_s.inspect
-
-      arity = args.size - 1
-      arity -= (opt.size - 1) if opt
-      arity -= 1 if splat
-      arity = -arity - 1 if opt or splat
-
-      # $arity will point to our received arguments count
-      aritycode = "var $arity = arguments.length;"
-
-      if arity < 0 # splat or opt args
-        aritycode + "if ($arity < #{-(arity + 1)}) { $opal.ac($arity, #{arity}, this, #{meth}); }"
-      else
-        aritycode + "if ($arity !== #{arity}) { $opal.ac($arity, #{arity}, this, #{meth}); }"
-      end
-    end
-
-    def process_args(exp, level)
-      args = []
-
-      exp.each do |a|
-        a = a.to_sym
-        next if a.to_s == '*'
-        a = lvar_to_js a
-        @scope.add_arg a
-        args << a
-      end
-
-      f(args.join(', '), exp)
-    end
-
-    # s(:self)  # => this
-    def process_self(sexp, level)
-      f(current_self, sexp)
-    end
-
-    # Returns the current value for 'self'. This will be native
-    # 'this' for methods and blocks, and the class name for class
-    # and module bodies.
-    # s(:self) => self or this or class name
-    def current_self
-      if @scope.class_scope?
-        @scope.name
-      elsif @scope.top? or @scope.iter?
-        'self'
-      else # defn, defs
-        'this'
-      end
-    end
-
-    # true literal
-    # s(:true) => true
-    def process_true(sexp, level)
-      f "true", sexp
-    end
-
-    # false literal
-    # s(:false) => false
-    def process_false(sexp, level)
-       f "false", sexp
-    end
-
-    # nil literal
-    # s(:nil) => nil
-    def process_nil(sexp, level)
-      f "nil", sexp
-    end
-
-    # s(:array [, sexp [, sexp]]) => [...]
-    def process_array(sexp, level)
-      return [f("[]", sexp)] if sexp.empty?
-
-      code, work = [], []
-
-      sexp.each do |current|
-        splat = current.first == :splat
-        part  = process current
-
-        if splat
-          if work.empty?
-            if code.empty?
-              code << f("[].concat(", sexp) << part << f(")", sexp)
-            else
-              code << f(".concat(", sexp) << part << f(")", sexp)
-            end
-          else
-            if code.empty?
-              code << f("[", sexp) << work << f("]", sexp)
-            else
-              code << f(".concat([", sexp) << work << f("])", sexp)
-            end
-
-            code << f(".concat(", sexp) << part << f(")", sexp)
-          end
-          work = []
-        else
-          work << f(", ", current) unless work.empty?
-          work << part
-        end
-      end
-
-      unless work.empty?
-        join = [f("[", sexp), work, f("]", sexp)]
-
-        if code.empty?
-          code = join
-        else
-          code.push([f(".concat(", sexp), join, f(")", sexp)])
-        end
-      end
+    def parse(source, file = '(string)')
+      @lexer = Lexer.new(source, file)
+      @file = file
+      @scopes = []
 
-      code
+      self.parse_to_sexp
     end
 
-    # s(:hash, key1, val1, key2, val2...)
-    def process_hash(sexp, level)
-      keys = []
-      vals = []
-
-      sexp.each_with_index do |obj, idx|
-        if idx.even?
-          keys << obj
-        else
-          vals << obj
-        end
-      end
-
-      if keys.all? { |k| [:sym, :str].include? k[0] }
-        hash_obj  = {}
-        hash_keys = []
-        keys.size.times do |i|
-          k = keys[i][1].to_s.inspect
-          hash_keys << k unless hash_obj.include? k
-          hash_obj[k] = process(vals[i])
-        end
-
-        result = []
-        @helpers[:hash2] = true
-
-        hash_keys.each do |k|
-          result << f(", ", sexp) unless result.empty?
-          result << f("#{k}: ", sexp)
-          result << hash_obj[k]
-        end
-
-        [f("$hash2([#{hash_keys.join ', '}], {", sexp), result, f("})", sexp)]
-      else
-        @helpers[:hash] = true
-        result = []
-
-        sexp.each do |p|
-          result << f(", ", p) unless result.empty?
-          result << process(p)
-        end
+    def parse_to_sexp
+      push_scope
+      result = do_parse
+      pop_scope
 
-        [f("$hash(", sexp), result, f(")", sexp)]
-      end
+      result
     end
 
-    # s(:while, exp, block, true)
-    def process_while(sexp, level)
-      expr, stmt = sexp
-      redo_var = @scope.new_temp
-      code = []
-
-      stmt_level = if level == :expr or level == :recv
-                     :stmt_closure
-                    else
-                      :stmt
-                    end
-
-      code << js_truthy(expr) << f("){", sexp)
-      pre = "while ("
-
-      in_while do
-        @while_loop[:closure] = true if stmt_level == :stmt_closure
-        @while_loop[:redo_var] = redo_var
-        body = process(stmt, :stmt)
-
-        if @while_loop[:use_redo]
-          pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code << f("#{redo_var}=false;", sexp)
-        end
-
-        code << body
-      end
-
-      code << f("}", sexp)
-      code.unshift f(pre, sexp)
-      @scope.queue_temp redo_var
-
-      if stmt_level == :stmt_closure
-        code.unshift f("(function() {", sexp)
-        code.push f("; return nil; }).call(#{current_self})", sexp)
-      end
-
-      code
+    def next_token
+      @lexer.next_token
     end
 
-    def process_until(exp, level)
-      expr, stmt = exp
-      redo_var   = @scope.new_temp
-      stmt_level = if level == :expr or level == :recv
-                     :stmt_closure
-                   else
-                     :stmt
-                   end
-
-      code = []
-      pre = "while (!("
-      code << js_truthy(expr) << f(")) {", exp)
-
-      in_while do
-        @while_loop[:closure] = true if stmt_level == :stmt_closure
-        @while_loop[:redo_var] = redo_var
-        body = process(stmt, :stmt)
-
-        if @while_loop[:use_redo]
-          pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code << f("#{redo_var}=false;", exp)
-        end
-
-        code << body
-      end
-
-      code << f("}", exp)
-      code.unshift f(pre, exp)
-      @scope.queue_temp redo_var
-
-      if stmt_level == :stmt_closure
-        code.unshift f("(function() {", exp)
-        code << f("; return nil; }).call(#{current_self})", exp)
-      end
-
-      code
+    def s(*parts)
+      sexp = Sexp.new(parts)
+      sexp.line = @lexer.line
+      sexp
     end
 
-    # alias foo bar
-    #
-    # s(:alias, s(:sym, :foo), s(:sym, :bar))
-    def process_alias(exp, level)
-      new = mid_to_jsid exp[0][1].to_s
-      old = mid_to_jsid exp[1][1].to_s
-
-      if [:class, :module].include? @scope.type
-        @scope.methods << "$#{exp[0][1].to_s}"
-        f("%s%s = %s%s" % [@scope.proto, new, @scope.proto, old], exp)
-      else
-        current = current_self
-        f("%s._proto%s = %s._proto%s" % [current, new, current, old], exp)
-      end
+    def push_scope(type = nil)
+      top = @scopes.last
+      scope = ParserScope.new type
+      scope.parent = top
+      @scopes << scope
+      @scope = scope
     end
 
-    def process_masgn(sexp, level)
-      lhs, rhs = sexp
-      tmp = @scope.new_temp
-      len = 0
-      code = []
-
-      if rhs[0] == :array
-        len = rhs.length - 1 # we are guaranteed an array of this length
-        code << f("#{tmp} = ", sexp) << process(rhs)
-      elsif rhs[0] == :to_ary
-        code << f("((#{tmp} = ", sexp) << process(rhs[1])
-        code << f(")._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))", sexp)
-      elsif rhs[0] == :splat
-        code << f("(#{tmp} = ", sexp) << process(rhs[1])
-        code << f(")['$to_a'] ? (#{tmp} = #{tmp}['$to_a']()) : (#{tmp})._isArray ?  #{tmp} : (#{tmp} = [#{tmp}])", sexp)
-      else
-        raise "Unsupported mlhs type"
-      end
-
-      lhs[1..-1].each_with_index do |l, idx|
-        code << f(", ", sexp) unless code.empty?
-
-        if l.first == :splat
-          if s = l[1]
-            s << s(:js_tmp, "$slice.call(#{tmp}, #{idx})")
-            code << process(s)
-          end
-        else
-          if idx >= len
-            assign = s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
-          else
-            assign = s(:js_tmp, "#{tmp}[#{idx}]")
-          end
-
-          if l[0] == :lasgn or l[0] == :iasgn or l[0] == :lvar
-            l << assign
-          elsif l[0] == :call
-            l[2] = "#{l[2]}=".to_sym
-            l.last << assign
-          elsif l[0] == :attrasgn
-            l.last << assign
-          else
-            raise "bad lhs for masgn: #{l.inspect}"
-          end
-
-          code << process(l)
-        end
-      end
-
-      @scope.queue_temp tmp
-      code
+    def pop_scope
+      @scopes.pop
+      @scope = @scopes.last
     end
 
-    def process_svalue(sexp, level)
-      process sexp[0], level
+    def on_error(t, val, vstack)
+      raise "parse error on value #{val.inspect} (#{token_to_str(t) || '?'}) :#{@file}:#{lexer.line}"
     end
 
-    # s(:lasgn, :lvar, rhs)
-    def process_lasgn(sexp, level)
-      lvar = sexp[0]
-      rhs  = sexp[1]
-      lvar = "#{lvar}$".to_sym if RESERVED.include? lvar.to_s
-
-      if @irb_vars and @scope.top?
-        [f("$opal.irb_vars.#{lvar} = ", sexp), process(rhs)]
-      else
-        @scope.add_local lvar
-        rhs = process(rhs)
-        result =  [f(lvar, sexp), f(" = ", sexp), rhs]
-
-        if level == :recv
-          result.unshift f("(", sexp)
-          result.push f(")", sexp)
-        end
-
-        result
-      end
+    def new_block(stmt = nil)
+      s = s(:block)
+      s << stmt if stmt
+      s
     end
 
-    # s(:lvar, :lvar)
-    def process_lvar(sexp, level)
-      lvar = sexp[0].to_s
-      lvar = "#{lvar}$" if RESERVED.include? lvar
-
-      if @irb_vars and @scope.top?
-        with_temp { |t| f("((#{t} = $opal.irb_vars.#{lvar}) == null ? nil : #{t})", sexp) }
+    def new_compstmt(block)
+      if block.size == 1
+        nil
+      elsif block.size == 2
+        block[1]
       else
-        f(lvar, sexp)
+        block.line = block[1].line
+        block
       end
     end
 
-    # s(:iasgn, :ivar, rhs)
-    def process_iasgn(exp, level)
-      ivar, rhs = exp
-      ivar = ivar.to_s[1..-1]
-      lhs = RESERVED.include?(ivar) ? "#{current_self}['#{ivar}']" : "#{current_self}.#{ivar}"
-      [f(lhs, exp), f(" = ", exp), process(rhs)]
-    end
-
-    # s(:ivar, :ivar)
-    def process_ivar(exp, level)
-      ivar = exp[0].to_s[1..-1]
-      part = RESERVED.include?(ivar) ? "['#{ivar}']" : ".#{ivar}"
-      @scope.add_ivar part
-      f("#{current_self}#{part}", exp)
-    end
-
-    # s(:gvar, gvar)
-    def process_gvar(sexp, level)
-      gvar = sexp[0].to_s[1..-1]
-      @helpers['gvars'] = true
-      f("$gvars[#{gvar.inspect}]", sexp)
-    end
+    def new_body(compstmt, res, els, ens)
+      s = compstmt || s(:block)
+      s.line = compstmt.line if compstmt
 
-    def process_nth_ref(sexp, level)
-      f("nil", sexp)
-    end
+      if res
+        s = s(:rescue, s)
+        res.each { |r| s << r }
+        s << els if els
+      end
 
-    # s(:gasgn, :gvar, rhs)
-    def process_gasgn(sexp, level)
-      gvar = sexp[0].to_s[1..-1]
-      rhs  = sexp[1]
-      @helpers['gvars'] = true
-      [f("$gvars[#{gvar.to_s.inspect}] = ", sexp), process(rhs)]
+      ens ? s(:ensure, s, ens) : s
     end
 
-    # s(:const, :const)
-    def process_const(sexp, level)
-      cname = sexp[0].to_s
-
-      if @const_missing
-        with_temp do |t|
-          f("((#{t} = $scope.#{cname}) == null ? $opal.cm(#{cname.inspect}) : #{t})", sexp)
-        end
-      else
-        f("$scope.#{cname}", sexp)
-      end
+    def new_def(line, recv, name, args, body)
+      body = s(:block, body) if body.type != :block
+      scope = s(:scope, body)
+      body << s(:nil) if body.size == 1
+      scope.line = body.line
+      args.line = line
+      s = s(:def, recv, name.to_sym, args, scope)
+      s.line = line
+      s.end_line = @lexer.line
+      s
     end
 
-    # s(:cdecl, :const, rhs)
-    def process_cdecl(sexp, level)
-      const, rhs = sexp
-      [f("$scope.#{const} = ", sexp), process(rhs)]
+    def new_class(path, sup, body)
+      scope = s(:scope)
+      scope << body unless body.size == 1
+      scope.line = body.line
+      s = s(:class, path, sup, scope)
+      s
     end
 
-    # s(:casgn, s(:const, ::A), :B, val)
-    # A::B = 100
-    def process_casgn(sexp, level)
-      lhs, const, rhs = sexp
-      [process(lhs), f("._scope.#{const} = ", sexp), process(rhs)]
+    def new_sclass(expr, body)
+      scope = s(:scope)
+      scope << body #unless body.size == 1
+      scope.line = body.line
+      s = s(:sclass, expr, scope)
+      s
     end
 
-    # s(:return [val])
-    def process_return(sexp, level)
-      val = process(sexp[0] || s(:nil))
-
-      if @scope.iter? and parent_def = @scope.find_parent_def
-        parent_def.catch_return = true
-        [f("$opal.$return(", sexp), val, f(")", sexp)]
-
-      elsif level == :expr and @scope.def?
-        @scope.catch_return = true
-        [f("$opal.$return(", sexp), val, f(")", sexp)]
-
-      elsif level == :stmt
-        [f("return ", sexp), val]
-
-      else
-        raise SyntaxError, "void value expression: cannot return as an expression"
-      end
+    def new_module(path, body)
+      scope = s(:scope)
+      scope << body unless body.size == 1
+      scope.line = body.line
+      s = s(:module, path, scope)
+      s
     end
 
-    # s(:xstr, content)
-    def process_xstr(sexp, level)
-      code = sexp.first.to_s
-      code += ";" if level == :stmt and !code.include?(';')
-
-      result = f(code, sexp)
-
-      level == :recv ? [f("(", sexp), result, f(")", sexp)] : result
+    def new_iter(args, body)
+      s = s(:iter, args)
+      s << body if body
+      s.end_line = @lexer.line
+      s
     end
 
-    # s(:dxstr, parts...)
-    def process_dxstr(sexp, level)
-      result = []
-      needs_sc = false
-
-      sexp.each do |p|
-        if String === p
-          result << f(p.to_s, sexp)
-          needs_sc = true if level == :stmt and !p.to_s.include?(';')
-        elsif p.first == :evstr
-          result.push(*process(p.last, :stmt))
-        elsif p.first == :str
-          result << f(p.last.to_s, p)
-          needs_sc = true if level == :stmt and !p.last.to_s.include?(';')
-        else
-          raise "Bad dxstr part"
-        end
-      end
-
-      result << f(";", sexp) if needs_sc
-
-      if level == :recv
-        [f("(", sexp), result, f(")", sexp)]
-      else
-        result
-      end
+    def new_if(expr, stmt, tail)
+      s = s(:if, expr, stmt, tail)
+      s.line = expr.line
+      s.end_line = @lexer.line
+      s
     end
 
-    # s(:dstr, parts..)
-    def process_dstr(sexp, level)
-      result = []
+    def new_args(norm, opt, rest, block)
+      res = s(:args)
 
-      sexp.each do |p|
-        result << f(" + ", sexp) unless result.empty?
-        if String === p
-          result << f(p.inspect, sexp)
-        elsif p.first == :evstr
-          result << f("(", p)
-          result << process(p.last)
-          result << f(")", p)
-        elsif p.first == :str
-          result << f(p.last.inspect, p)
-        else
-          raise "Bad dstr part"
+      if norm
+        norm.each do |arg|
+          scope.add_local arg
+          res << arg
         end
       end
 
-      if level == :recv
-        [f("(", sexp), result, f(")", sexp)]
-      else
-        result
-      end
-    end
-
-    def process_dsym(sexp, level)
-      result = []
-
-      sexp.each do |p|
-        result << f(" + ", sexp) unless result.empty?
-
-        if String === p
-          result << f(p.inspect, sexp)
-        elsif p.first == :evstr
-          result << process(s(:call, p.last, :to_s, s(:arglist)))
-        elsif p.first == :str
-          result << f(p.last.inspect, sexp)
-        else
-          raise "Bad dsym part"
+      if opt
+        opt[1..-1].each do |_opt|
+          res << _opt[1]
         end
       end
 
-      [f("(", sexp), result, f(")", sexp)]
-    end
-
-    # s(:if, test, truthy, falsy)
-    def process_if(sexp, level)
-      test, truthy, falsy = sexp
-      returnable = (level == :expr or level == :recv)
-
-      if returnable
-        truthy = returns(truthy || s(:nil))
-        falsy = returns(falsy || s(:nil))
-      end
-
-      # optimize unless (we don't want else unless we need to)
-      if falsy and !truthy
-        truthy = falsy
-        falsy  = nil
-        check  = js_falsy test
-      else
-        check = js_truthy test
+      if rest
+        res << rest
+        rest_str = rest.to_s[1..-1]
+        scope.add_local rest_str.to_sym unless rest_str.empty?
       end
 
-      result = [f("if (", sexp), check, f(") {\n", sexp)]
-
-      indent { result.push(f(@indent, sexp), process(truthy, :stmt)) } if truthy
-
-      outdent = @indent
-      indent { result.push(f("\n#{outdent}} else {\n#@indent", sexp), process(falsy, :stmt)) } if falsy
-
-      result << f("\n#@indent}", sexp)
-
-      if returnable
-        result.unshift f("(function() { ", sexp)
-        result.push f("; return nil; }).call(#{current_self})", sexp)
+      if block
+        res << block
+        scope.add_local block.to_s[1..-1].to_sym
       end
 
-      result
-    end
+      res << opt if opt
 
-    def js_truthy_optimize(sexp)
-      if sexp.first == :call
-        mid = sexp[2]
-        if mid == :block_given?
-          return process sexp
-        elsif COMPARE.include? mid.to_s
-          return process sexp
-        elsif mid == :"=="
-          return process sexp
-        end
-      elsif [:lvar, :self].include? sexp.first
-        [process(sexp.dup), f(" !== false && ", sexp), process(sexp.dup), f(" !== nil", sexp)]
-      end
+      res
     end
 
-    def js_truthy(sexp)
-      if optimized = js_truthy_optimize(sexp)
-        return optimized
-      end
+    def new_block_args(norm, opt, rest, block)
+      res = s(:array)
 
-      with_temp do |tmp|
-        [f("(#{tmp} = ", sexp), process(sexp), f(") !== false && #{tmp} !== nil", sexp)]
+      if norm
+        norm.each do |arg|
+          if arg.is_a? Symbol
+            scope.add_local arg
+            res << s(:lasgn, arg)
+          else
+            res << arg
+          end
+        end
       end
-    end
 
-    def js_falsy(sexp)
-      if sexp.first == :call
-        mid = sexp[2]
-        if mid == :block_given?
-          return handle_block_given(sexp, true)
+      if opt
+        opt[1..-1].each do |_opt|
+          res << s(:lasgn, _opt[1])
         end
       end
 
-      with_temp do |tmp|
-        result = []
-        result << f("(#{tmp} = ", sexp)
-        result << process(sexp)
-        result << f(") === false || #{tmp} === nil", sexp)
-        result
+      if rest
+        r = rest.to_s[1..-1].to_sym
+        res << s(:splat, s(:lasgn, r))
+        scope.add_local r
       end
-    end
-
-    # s(:and, lhs, rhs)
-    def process_and(sexp, level)
-      lhs, rhs = sexp
-      t = nil
-      tmp = @scope.new_temp
 
-      if t = js_truthy_optimize(lhs)
-        result = []
-        result << f("((#{tmp} = ", sexp) << t
-        result << f(") ? ", sexp) << process(rhs)
-        result << f(" : #{tmp})", sexp)
-        @scope.queue_temp tmp
-
-        return result
+      if block
+        b = block.to_s[1..-1].to_sym
+        res << s(:block_pass, s(:lasgn, b))
+        scope.add_local b
       end
 
-      @scope.queue_temp tmp
-
-      [f("(#{tmp} = ", sexp), process(lhs), f(", #{tmp} !== false && #{tmp} !== nil ? ", sexp), process(rhs), f(" : #{tmp})", sexp)]
-
-    end
-
-    # s(:or, lhs, rhs)
-    def process_or(sexp, level)
-      lhs, rhs = sexp
+      res << opt if opt
 
-      with_temp do |tmp|
-        lhs = process lhs
-        rhs = process rhs
-        [f("(((#{tmp} = ", sexp), lhs, f(") !== false && #{tmp} !== nil) ? #{tmp} : ", sexp), rhs, f(")", sexp)]
-      end
-    end
+      args = res.size == 2 && norm ? res[1] : s(:masgn, res)
 
-    # s(:yield, arg1, arg2)
-    def process_yield(sexp, level)
-      call = handle_yield_call sexp, level
-
-      if level == :stmt
-        [f("if (", sexp), call, f(" === $breaker) return $breaker.$v")]
+      if args.type == :array
+        s(:masgn, args)
       else
-        with_temp do |tmp|
-          [f("(((#{tmp} = ", sexp), call, f(") === $breaker) ? $breaker.$v : #{tmp})", sexp)]
-        end
-      end
-    end
-
-    # special opal yield assign, for `a = yield(arg1, arg2)` to assign
-    # to a temp value to make yield expr into stmt.
-    #
-    # level will always be stmt as its the reason for this to exist
-    #
-    # s(:yasgn, :a, s(:yield, arg1, arg2))
-    def process_yasgn(sexp, level)
-      call = handle_yield_call s(*sexp[1][1..-1]), :stmt
-
-      [f("if ((#{sexp[0]} = ", sexp), call, f(") === $breaker) return $breaker.$v", sexp)]
-    end
-
-    # Created by `#returns()` for when a yield statement should return
-    # it's value (its last in a block etc).
-    def process_returnable_yield(sexp, level)
-      call = handle_yield_call sexp, level
-
-      with_temp do |tmp|
-        [f("return #{tmp} = ", sexp), call,
-                    f(", #{tmp} === $breaker ? #{tmp} : #{tmp}")]
+        args
       end
     end
 
-    def handle_yield_call(sexp, level)
-      @scope.uses_block!
-
-      splat = sexp.any? { |s| s.first == :splat }
+    def new_call(recv, meth, args = nil)
+      call = s(:call, recv, meth)
+      args = s(:arglist) unless args
+      args.type = :arglist if args.type == :array
+      call << args
 
-      if !splat and sexp.size == 1
-        return [f("$opal.$yield1(#{@scope.block_name || '$yield'}, "), process(sexp[0]), f(")")]
+      if recv
+        call.line = recv.line
+      elsif args[1]
+        call.line = args[1].line
       end
 
-      args = process_arglist sexp, level
-      y = @scope.block_name || '$yield'
-
-      if splat
-        [f("$opal.$yieldX(#{y}, ", sexp), args, f(")")]
+      # fix arglist spilling over into next line if no args
+      if args.length == 1
+        args.line = call.line
       else
-        [f("$opal.$yieldX(#{y}, [", sexp), args, f("])")]
+        args.line = args[1].line
       end
-    end
 
-    def process_break(sexp, level)
-      val = sexp.empty? ? f('nil', sexp) : process(sexp[0])
-      if in_while?
-        @while_loop[:closure] ? [f("return ", sexp), val, f("", sexp)] : f("break;", sexp)
-      elsif @scope.iter?
-        error "break must be used as a statement" unless level == :stmt
-        [f("return ($breaker.$v = ", sexp), val, f(", $breaker)", sexp)]
-      else
-        error "void value expression: cannot use break outside of iter/while"
-      end
+      call
     end
 
-    # s(:case, expr, when1, when2, ..)
-    def process_case(exp, level)
-      pre, code = [], []
-
-      # are we inside a statement_closure
-      returnable = level != :stmt
-      done_else = false
-
-      in_case do
-        if cond = exp[0]
-          @case_stmt[:cond] = true
-          @scope.add_local "$case"
-          expr = process cond
-          pre << f("$case = ", exp) << expr << f(";", exp)
-        end
-
-        exp[1..-1].each do |wen|
-          if wen and wen.first == :when
-            returns(wen) if returnable
-            wen = process(wen, :stmt)
-            code << f("else ", exp) unless code.empty?
-            code << wen
-          elsif wen # s(:else)
-            done_else = true
-            wen = returns(wen) if returnable
-            code << f("else {", exp) << process(wen, :stmt) << f("}", exp)
-          end
-        end
-      end
-
-      code << f("else { return nil }", exp) if returnable and !done_else
-
-      code.unshift pre
-
-      if returnable
-        code.unshift f("(function() { ", exp)
-        code << f(" }).call(#{current_self})", exp)
-      end
-
-      code
+    def add_block_pass(arglist, block)
+      arglist << block if block
+      arglist
     end
 
-    # when foo
-    #   bar
-    #
-    # s(:when, s(:array, foo), bar)
-    def process_when(exp, level)
-      arg = exp[0][1..-1]
-      body = exp[1] || s(:nil)
-      body = process body, level
-
-      test = []
-      arg.each do |a|
-        test << f(" || ") unless test.empty?
-
-        if a.first == :splat # when inside another when means a splat of values
-          call = f("$splt[i]['$===']($case)", a)
-
-          splt = [f("(function($splt) { for(var i = 0; i < $splt.length; i++) {", exp)]
-          splt << f("if (") << call << f(") { return true; }", exp)
-          splt << f("} return false; }).call(#{current_self}, ", exp)
-          splt << process(a[1]) << f(")")
+    def new_op_asgn(op, lhs, rhs)
+      case op
+      when :"||"
+        result = s(:op_asgn_or, new_gettable(lhs))
+        result << (lhs << rhs)
+      when :"&&"
+        result = s(:op_asgn_and, new_gettable(lhs))
+        result << (lhs << rhs)
+      else
+        result = lhs
+        result << new_call(new_gettable(lhs), op, s(:arglist, rhs))
 
-          test << splt
-        else
-          if @case_stmt[:cond]
-            call = s(:call, a, :===, s(:arglist, s(:js_tmp, "$case")))
-            test << process(call)
-          else
-            test << js_truthy(a)
-          end
-        end
       end
 
-      [f("if ("), test, f(") {#@space"), body, f("#@space}")]
-    end
-
-    # lhs =~ rhs
-    #
-    # s(:match3, lhs, rhs) # => s(:call, lhs, :=~, s(:arglist, rhs))
-    def process_match3(sexp, level)
-      process s(:call, sexp[0], :=~, s(:arglist, sexp[1])), level
+      result.line = lhs.line
+      result
     end
 
-    # @@class_variable
-    #
-    # s(:cvar, name)
-    def process_cvar(exp, level)
-      with_temp do |tmp|
-        f("((#{tmp} = $opal.cvars['#{exp[0]}']) == null ? nil : #{tmp})", exp)
+    def new_assign(lhs, rhs)
+      case lhs.type
+      when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl, :nth_ref
+        lhs << rhs
+        lhs
+      when :call, :attrasgn
+        lhs.last << rhs
+        lhs
+      when :colon2
+        lhs << rhs
+        lhs.type = :casgn
+        lhs
+      when :colon3
+        lhs << rhs
+        lhs.type = :casgn3
+        lhs
+      else
+        raise "Bad lhs for new_assign: #{lhs.type}"
       end
     end
 
-    # @@name = rhs
-    #
-    # s(:cvasgn, :@@name, rhs)
-    def process_cvasgn(exp, level)
-      "($opal.cvars['#{exp[0]}'] = #{process exp[1]})"
-    end
-
-    # s(:cvdecl, :@@foo, value) # => ($opal.cvars['@@foo'] = value)
-    def process_cvdecl(exp, level)
-      [f("($opal.cvars['#{exp[0]}'] = ", exp), process(exp[1]), f(")", exp)]
-    end
-
-    # BASE::NAME
-    #
-    # s(:colon2, base, :NAME)
-    def process_colon2(sexp, level)
-      base, cname = sexp
-      result = []
-
-      if @const_missing
-        with_temp do |t|
-          base = process base
-
-          result << f("((#{t} = (", sexp) << base << f(")._scope).", sexp)
-          result << f("#{cname} == null ? #{t}.cm('#{cname}') : #{t}.#{cname})", sexp)
-        end
+    def new_assignable(ref)
+      case ref.type
+      when :ivar
+        ref.type = :iasgn
+      when :const
+        ref.type = :cdecl
+      when :identifier
+        scope.add_local ref[1] unless scope.has_local? ref[1]
+        ref.type = :lasgn
+      when :gvar
+        ref.type = :gasgn
+      when :cvar
+        ref.type = :cvdecl
       else
-        result << f("(", sexp) << process(base) << f(")._scope.#{cname}", sexp)
+        raise "Bad new_assignable type: #{ref.type}"
       end
 
-      result
-    end
-
-    # s(:colon3, :CONST_NAME) # => $opal.Object._scope.CONST_NAME
-    def process_colon3(exp, level)
-      with_temp do |t|
-        f("((#{t} = $opal.Object._scope.#{exp[0]}) == null ? $opal.cm('#{exp[0]}') : #{t})", exp)
-      end
+      ref
     end
 
-    # super a, b, c
-    #
-    # s(:super, arg1, arg2, ...)
-    def process_super(sexp, level)
-      args = []
-      sexp.each do |part|
-        args << f(", ", sexp) unless args.empty?
-        args << process(part)
-      end
-
-      js_super [f("[", sexp), args, f("]", sexp)], false, sexp
-    end
+    def new_gettable(ref)
+      res = case ref.type
+            when :lasgn
+              s(:lvar, ref[1])
+            when :iasgn
+              s(:ivar, ref[1])
+            when :gasgn
+              s(:gvar, ref[1])
+            when :cvdecl
+              s(:cvar, ref[1])
+            else
+              raise "Bad new_gettable ref: #{ref.type}"
+            end
 
-    # super
-    #
-    # s(:zsuper)
-    def process_zsuper(exp, level)
-      if @scope.def?
-        @scope.uses_zuper = true
-        js_super f("$zuper", exp), true, exp
-      else
-        js_super f("$slice.call(arguments)", exp), true, exp
-      end
+      res.line = ref.line
+      res
     end
 
-    def js_super args, pass_block, sexp
-      if @scope.def_in_class?
-        @scope.uses_block!
-        mid = @scope.mid.to_s
-
-        if @scope.uses_super
-          sid = @scope.uses_super
-        else
-          sid = @scope.uses_super = "super_#{unique_temp}"
-        end
-
-        if pass_block
-          @scope.uses_block!
-          [f("(#{sid}._p = $iter, #{sid}.apply(#{current_self}, ", sexp), args, f("))", sexp)]
-        else
-          [f("#{sid}.apply(#{current_self}, ", sexp), args, f(")", sexp)]
-        end
-
-
-      elsif @scope.type == :def
-        @scope.uses_block!
-        @scope.identify!
-        cls_name = @scope.parent.name || "#{current_self}._klass._proto"
-        jsid     = mid_to_jsid @scope.mid.to_s
-
-        if pass_block
-          @scope.uses_block!
-          iter = "$iter"
-        else
-          iter = "null"
-        end
-
-        if @scope.defs
-          [f("$opal.dispatch_super(this, #{@scope.mid.to_s.inspect},", sexp), args, f(", #{iter}, #{cls_name})", sexp)]
+    def new_var_ref(ref)
+      case ref.type
+      when :self, :nil, :true, :false, :line, :file
+        ref
+      when :const
+        ref
+      when :ivar, :gvar, :cvar
+        ref
+      when :int
+        # this is when we passed __LINE__ which is converted into :int
+        ref
+      when :str
+        # returns for __FILE__ as it is converted into str
+        ref
+      when :identifier
+        if scope.has_local? ref[1]
+          s(:lvar, ref[1])
         else
-          [f("$opal.dispatch_super(#{current_self}, #{@scope.mid.to_s.inspect}, ", sexp), args, f(", #{iter})", sexp)]
+          s(:call, nil, ref[1], s(:arglist))
         end
-
-      elsif @scope.type == :iter
-        chain, defn, mid = @scope.get_super_chain
-        trys = chain.map { |c| "#{c}._sup" }.join ' || '
-        [f("(#{trys} || #{current_self}._klass._super._proto[#{mid}]).apply(#{current_self}, ", sexp), args, f(")", sexp)]
       else
-        raise "Cannot call super() from outside a method block"
+        raise "Bad var_ref type: #{ref.type}"
       end
     end
 
-    # a ||= rhs
-    #
-    # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, rhs))
-    def process_op_asgn_or(exp, level)
-      process s(:or, exp[0], exp[1])
-    end
-
-    # a &&= rhs
-    #
-    # s(:op_asgn_and, s(:lvar, :a), s(:lasgn, :a, rhs))
-    def process_op_asgn_and(sexp, level)
-      process s(:and, sexp[0], sexp[1])
-    end
-
-    # lhs[args] ||= rhs
-    #
-    # s(:op_asgn1, lhs, args, :||, rhs)
-    def process_op_asgn1(sexp, level)
-      lhs, arglist, op, rhs = sexp
-
-      with_temp do |a| # args
-        with_temp do |r| # recv
-          args = process arglist[1]
-          recv = process lhs
-
-          aref = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
-          aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
-          orop = s(:or, aref, aset)
+    def new_super(args)
+      args = (args || s(:arglist))
 
-          result = []
-          result << f("(#{a} = ", sexp) << args << f(", #{r} = ", sexp)
-          result << recv << f(", ", sexp) << process(orop)
-          result << f(")", sexp)
-          result
-        end
+      if args.type == :array
+        args.type = :arglist
       end
-    end
-
-    # lhs.b += rhs
-    #
-    # s(:op_asgn2, lhs, :b=, :+, rhs)
-    def process_op_asgn2(sexp, level)
-      lhs = process sexp[0]
-      mid = sexp[1].to_s[0..-2]
-      op  = sexp[2]
-      rhs = sexp[3]
-
-      if op.to_s == "||"
-        with_temp do |temp|
-          getr = s(:call, s(:js_tmp, temp), mid, s(:arglist))
-          asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
-          orop = s(:or, getr, asgn)
 
-          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(orop), f(")", sexp)]
-        end
-      elsif op.to_s == '&&'
-        with_temp do |temp|
-          getr = s(:call, s(:js_tmp, temp), mid, s(:arglist))
-          asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
-          andop = s(:and, getr, asgn)
-
-          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(andop), f(")", sexp)]
-        end
-      else
-        with_temp do |temp|
-          getr = s(:call, s(:js_tmp, temp), mid, s(:arglist))
-          oper = s(:call, getr, op, s(:arglist, rhs))
-          asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, oper))
-
-          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(asgn), f(")", sexp)]
-        end
-      end
+      s(:super, args)
     end
 
-    # s(:ensure, body, ensure)
-    def process_ensure(exp, level)
-      begn = exp[0]
-      if level == :recv || level == :expr
-        retn = true
-        begn = returns begn
-      end
-
-      result = []
-      body = process begn, level
-      ensr = exp[1] || s(:nil)
-      ensr = process ensr, level
-
-      body = [f("try {\n", exp), body, f("}", exp)]
-
-      result << body << f("#{@space}finally {#@space", exp) << ensr << f("}", exp)
-
-      if retn
-        [f("(function() { ", exp), result, f("; }).call(#{current_self})", exp)]
-      else
-        result
-      end
+    def new_yield(args)
+      args = (args || s(:arglist))[1..-1]
+      s(:yield, *args)
     end
 
-    def process_rescue(exp, level)
-      body = exp.first.first == :resbody ? s(:nil) : exp[0]
-      body = indent { process body, level }
-      handled_else = false
-
-      parts = []
-      exp[1..-1].each do |a|
-        handled_else = true unless a.first == :resbody
-        part = indent { process a, level }
-
-        unless parts.empty?
-          parts << f("else ", exp)
-        end
-
-        parts << part
-      end
-      # if no rescue statement captures our error, we should rethrow
-      parts << indent { f("else { throw $err; }", exp) } unless handled_else
-
-      code = []
-      code << f("try {#@space#{INDENT}", exp)
-      code << body
-      code << f("#@space} catch ($err) {#@space", exp)
-      code << parts
-      code << f("#@space}", exp)
-
-      if level == :expr
-        code.unshift f("(function() { ", exp)
-        code << f(" }).call(#{current_self})", exp)
+    def new_xstr(str)
+      return s(:xstr, '') unless str
+      case str.type
+      when :str   then str.type = :xstr
+      when :dstr  then str.type = :dxstr
+      when :evstr then str = s(:dxstr, '', str)
       end
 
-      code
+      str
     end
 
-    def process_resbody(exp, level)
-      args = exp[0]
-      body = exp[1]
-
-      body = process(body || s(:nil), level)
-      types = args[1..-1]
-      types.pop if types.last and types.last.first != :const
-
-      err = []
-      types.each do |t|
-        err << f(", ", exp) unless err.empty?
-        call = s(:call, t, :===, s(:arglist, s(:js_tmp, "$err")))
-        a = process call
-        err << a
-      end
-      err << f("true", exp) if err.empty?
-
-      if Array === args.last and [:lasgn, :iasgn].include? args.last.first
-        val = args.last
-        val[2] = s(:js_tmp, "$err")
-        val = [process(val) , f(";", exp)]
+    def new_dsym(str)
+      return s(:nil) unless str
+      case str.type
+      when :str
+        str.type = :sym
+        str[1] = str[1].to_sym
+      when :dstr
+        str.type = :dsym
       end
 
-      val = [] unless val
-
-      [f("if (", exp), err, f("){#@space", exp), val, body, f("}", exp)]
-    end
-
-    # FIXME: Hack.. grammar should remove top level begin.
-    def process_begin(exp, level)
-      process exp[0], level
+      str
     end
 
-    def process_next(exp, level)
-      if in_while?
-        f("continue;", exp)
+    def new_str(str)
+      # cover empty strings
+      return s(:str, "") unless str
+      # catch s(:str, "", other_str)
+      if str.size == 3 and str[1] == "" and str.type == :str
+        return str[2]
+      # catch s(:str, "content", more_content)
+      elsif str.type == :str && str.size > 3
+        str.type = :dstr
+        str
+      # top level evstr should be a dstr
+      elsif str.type == :evstr
+        s(:dstr, "", str)
       else
-        result = []
-        result << f("return ", exp)
-
-        result << (exp.empty? ? f('nil', exp) : process(exp[0]))
-        result << f(";", exp)
+        str
+      end
+    end
 
-        result
+    def new_regexp(reg, ending)
+      return s(:regexp, //) unless reg
+      case reg.type
+      when :str
+        s(:regexp, Regexp.new(reg[1], ending))
+      when :evstr
+        s(:dregx, "", reg)
+      when :dstr
+        reg.type = :dregx
+        reg
       end
     end
 
-    # s(:redo) # => $redo_var = true
-    # Only currently supported inside while loops. Simply sets the redo variable
-    # for the loop to true.
-    def process_redo(exp, level)
-      if in_while?
-        @while_loop[:use_redo] = true
-        f("#{@while_loop[:redo_var]} = true", exp)
+    def str_append(str, str2)
+      return str2 unless str
+      return str unless str2
+
+      if str.type == :evstr
+        str = s(:dstr, "", str)
+      elsif str.type == :str
+        str = s(:dstr, str[1])
       else
-        f("REDO()", exp)
+        #puts str.type
       end
+      str << str2
+      str
     end
   end
 end