parser.rb

require 'opal/lexer'
require 'opal/grammar'
require 'opal/target_scope'
require 'opal/version'

module Opal
  class 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

      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] == true)
      @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, :redo
        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
          if sexp[2][2]
            sexp[2][2] = returns sexp[2][2]
          else
            sexp[2][2] = returns s(:nil)
          end
        end
        sexp
      when :ensure
        sexp[1] = returns sexp[1]
        sexp
      when :begin
        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, block_args [, body) => (function() { ... })
    def process_iter(sexp, level)
      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"

          params = js_block_args(args[1..-1])

          args[1..-1].each_with_index do |arg, idx|
            if arg[0] == :lasgn
              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#{@indent}", sexp)]
              else
                code << f("if (#{arg} == null) #{arg} = nil;\n#{@indent}", sexp)
              end
            elsif arg[0] == :array
              arg[1..-1].each_with_index do |arg, midx|
                arg = arg[1]
                arg = "#{arg}$" if RESERVED.include? arg.to_s
                code << f("#{arg} = #{params[idx]}[#{midx}];\n#{@indent}")
              end
            else
              raise "Bad block_arg type: #{arg[0]}"
            end
          end

          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)

      itercode
    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)
      result = []
      sexp.each do |arg|
        if arg[0] == :lasgn
          ref = lvar_to_js(arg[1])
          @scope.add_arg ref
          result << ref
        elsif arg[0] == :array
          result << @scope.next_temp
        else
          raise "Bad js_block_arg: #{arg[0]}"
        end
      end

      result
    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 and iter == 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 = process(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"

          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, level
    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, level
    end

    def js_def(recvr, mid, args, stmts, line, end_line, sexp, level)
      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 (#{lvar_to_js 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)

      def_code = 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

      if level == :expr
        def_code = [f("("), def_code, f(", nil)")]
      end

      return def_code
    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

      code
    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

        [f("$hash(", sexp), result, f(")", sexp)]
      end
    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
    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
    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
    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} = $opal.to_ary("), process(rhs[1]), f(")")]
      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
    end

    def process_svalue(sexp, level)
      process sexp[0], level
    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
    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) }
      else
        f(lvar, sexp)
      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 process_nth_ref(sexp, level)
      f("nil", sexp)
    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)]
    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
    end

    # s(:cdecl, :const, rhs)
    def process_cdecl(sexp, level)
      const, rhs = sexp
      [f("$scope.#{const} = ", sexp), process(rhs)]
    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)]
    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
    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
    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
    end

    # s(:dstr, parts..)
    def process_dstr(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 << f("(", p)
          result << process(p.last)
          result << f(")", p)
        elsif p.first == :str
          result << f(p.last.inspect, p)
        else
          raise "Bad dstr part"
        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"
        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
      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)
      end

      result
    end

    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
    end

    def js_truthy(sexp)
      if optimized = js_truthy_optimize(sexp)
        return optimized
      end

      with_temp do |tmp|
        [f("(#{tmp} = ", sexp), process(sexp), f(") !== false && #{tmp} !== nil", sexp)]
      end
    end

    def js_falsy(sexp)
      if sexp.first == :call
        mid = sexp[2]
        if mid == :block_given?
          return handle_block_given(sexp, true)
        end
      end

      with_temp do |tmp|
        result = []
        result << f("(#{tmp} = ", sexp)
        result << process(sexp)
        result << f(") === false || #{tmp} === nil", sexp)
        result
      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
      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

      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

    # 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")]
      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}")]
      end
    end

    def handle_yield_call(sexp, level)
      @scope.uses_block!

      splat = sexp.any? { |s| s.first == :splat }

      if !splat and sexp.size == 1
        return [f("$opal.$yield1(#{@scope.block_name || '$yield'}, "), process(sexp[0]), f(")")]
      end

      args = process_arglist sexp, level
      y = @scope.block_name || '$yield'

      if splat
        [f("$opal.$yieldX(#{y}, ", sexp), args, f(")")]
      else
        [f("$opal.$yieldX(#{y}, [", sexp), args, f("])")]
      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
    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
    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(")")

          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
    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)
      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
      else
        result << f("(", sexp) << process(base) << f(")._scope.#{cname}", sexp)
      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
    end

    def process_casgn3(sexp, level)
      cid, rhs = sexp
      [f("$opal.Object._scope.#{cid} = "), process(rhs)]
    end

    # super a, b, c
    #
    # s(:super, arg1, arg2, ...)
    def process_super(sexp, level)
      args, iter = sexp[0], sexp[1]

      if args or iter
        if iter
          iter = process(iter)
        else
          iter = f("null")
        end

        args ||= s(:arglist)

        splat = args[1..-1].any? { |s| s.first == :splat }
        args = process args

        unless splat
          args = [f("["), args, f("]")]
        end
      else
        @scope.uses_block!

        iter = f("$iter")

        if @scope.def?
          @scope.uses_zuper = true
          args = f("$zuper", sexp)
        else
          args = f("$slice.call(arguments)", sexp)
        end
      end

      if @scope.type == :def
        @scope.uses_block!
        scope = @scope.identify!
        cls_name = @scope.parent.name || "#{current_self}._klass._proto"

        if @scope.defs
          [f("$opal.dispatch_super(this, #{@scope.mid.to_s.inspect}, #{scope},", sexp), args, f(", "), iter, f(", #{cls_name})", sexp)]
        else
          [f("$opal.dispatch_super(#{current_self}, #{@scope.mid.to_s.inspect}, #{scope}, ", sexp), args, f(", "), iter, f(")", sexp)]
        end

      elsif @scope.type == :iter
        chain, _, 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"
      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)

          result = []
          result << f("(#{a} = ", sexp) << args << f(", #{r} = ", sexp)
          result << recv << f(", ", sexp) << process(orop)
          result << f(")", sexp)
          result
        end
      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
    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
    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)
      end

      code
    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)]
      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
    end

    def process_next(exp, level)
      if in_while?
        f("continue;", exp)
      else
        result = []
        result << f("return ", exp)

        result << (exp.empty? ? f('nil', exp) : process(exp[0]))
        result << f(";", exp)

        result
      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)
      elsif @scope.iter?
        f("return #{@scope.identity}.apply(null, $slice.call(arguments))")
      else
        f("REDO()", exp)
      end
    end
  end
end