opal-cj 0.7.0.beta1

data/lib/opal/nodes/call_special.rb

@@ -0,0 +1,178 @@
+require 'opal/nodes/base'
+require 'opal/nodes/call'
+
+module Opal
+  module Nodes
+    # recv.mid = rhs
+    # s(:recv, :mid=, s(:arglist, rhs))
+    class AttrAssignNode < CallNode
+      handle :attrasgn
+
+      children :recvr, :meth, :arglist
+
+      def default_compile
+        # Skip, for now, if the method has square brackets: []=
+        return super if meth.to_s !~ /^\w+=$/
+
+        with_temp do |args_tmp|
+          with_temp do |recv_tmp|
+            args = expr(arglist)
+            mid = mid_to_jsid meth.to_s
+            push "((#{args_tmp} = [", args, "]), "+
+                 "#{recv_tmp} = ", recv(recv_sexp), ", ",
+                 recv_tmp, mid, ".apply(#{recv_tmp}, #{args_tmp}), "+
+                 "#{args_tmp}[#{args_tmp}.length-1])"
+          end
+        end
+      end
+    end
+
+    # lhs =~ rhs
+    # s(:match3, lhs, rhs)
+    class Match3Node < Base
+      handle :match3
+
+      children :lhs, :rhs
+
+      def compile
+        sexp = s(:call, lhs, :=~, s(:arglist, rhs))
+        push process(sexp, @level)
+      end
+    end
+
+    # a ||= rhs
+    # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, rhs))
+    class OpAsgnOrNode < Base
+      handle :op_asgn_or
+
+      children :recvr, :rhs
+
+      def compile
+        sexp = s(:or, recvr, rhs)
+        push expr(sexp)
+      end
+    end
+
+    # a &&= rhs
+    # s(:op_asgn_and, s(:lvar, :a), s(:lasgn, a:, rhs))
+    class OpAsgnAndNode < Base
+      handle :op_asgn_and
+
+      children :recvr, :rhs
+
+      def compile
+        sexp = s(:and, recvr, rhs)
+        push expr(sexp)
+      end
+    end
+
+    # lhs[args] ||= rhs
+    # s(:op_asgn1, lhs, args, :||, rhs)
+    class OpAsgn1Node < Base
+      handle :op_asgn1
+
+      children :lhs, :args, :op, :rhs
+
+      def first_arg
+        args[1]
+      end
+
+      def compile
+        case op.to_s
+        when '||' then compile_or
+        when '&&' then compile_and
+        else compile_operator
+        end
+      end
+
+      def compile_operator
+        with_temp do |a| # args
+          with_temp do |r| # recv
+            cur = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
+            rhs = s(:call, cur, op.to_sym, s(:arglist, self.rhs))
+            call = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
+
+            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
+            push ", ", expr(call), ")"
+          end
+        end
+      end
+
+      def compile_or
+        with_temp do |a| # args
+          with_temp do |r| # recv
+            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)
+
+            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
+            push ", ", expr(orop), ")"
+          end
+        end
+      end
+
+      def compile_and
+        with_temp do |a| # args
+          with_temp do |r| # recv
+            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))
+            andop = s(:and, aref, aset)
+
+            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
+            push ", ", expr(andop), ")"
+          end
+        end
+      end
+    end
+
+    # lhs.b += rhs
+    # s(:op_asgn2, lhs, :b=, :+, rhs)
+    class OpAsgn2Node < Base
+      handle :op_asgn2
+
+      children :lhs, :mid, :op, :rhs
+
+      def meth
+        mid.to_s[0..-2]
+      end
+
+      def compile
+        case op.to_s
+        when '||' then compile_or
+        when '&&' then compile_and
+        else compile_operator
+        end
+      end
+
+      def compile_or
+        with_temp do |tmp|
+          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
+          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, rhs))
+          orop = s(:or, getr, asgn)
+
+          push "(#{tmp} = ", expr(lhs), ", ", expr(orop), ")"
+        end
+      end
+
+      def compile_and
+        with_temp do |tmp|
+          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
+          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, rhs))
+          andop = s(:and, getr, asgn)
+
+          push "(#{tmp} = ", expr(lhs), ", ", expr(andop), ")"
+        end
+      end
+
+      def compile_operator
+        with_temp do |tmp|
+          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
+          oper = s(:call, getr, op, s(:arglist, rhs))
+          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, oper))
+
+          push "(#{tmp} = ", expr(lhs), ", ", expr(asgn), ")"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/case.rb

@@ -0,0 +1,96 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class CaseNode < Base
+      handle :case
+
+      children :condition
+
+      def compile
+        handled_else = false
+
+        compiler.in_case do
+          if condition
+            case_stmt[:cond] = true
+            add_local '$case'
+
+            push "$case = ", expr(condition), ";"
+          end
+
+          case_parts.each_with_index do |wen, idx|
+            if wen and wen.type == :when
+              compiler.returns(wen) if needs_closure?
+              push "else " unless idx == 0
+              push stmt(wen)
+            elsif wen # s(:else)
+              handled_else = true
+              wen = compiler.returns(wen) if needs_closure?
+              push "else {", stmt(wen), "}"
+            end
+          end
+
+          # if we are having a closure, we must return a usable value
+          if needs_closure? and !handled_else
+            push "else { return nil }"
+          end
+
+          wrap '(function() {', '})()' if needs_closure?
+        end
+      end
+
+      def needs_closure?
+        !stmt?
+      end
+
+      def case_parts
+        children[1..-1]
+      end
+
+      def case_stmt
+        compiler.case_stmt
+      end
+    end
+
+    class WhenNode < Base
+      handle :when
+
+      children :whens, :body
+
+      def compile
+        push "if ("
+
+        when_checks.each_with_index do |check, idx|
+          push ' || ' unless idx == 0
+
+          if check.type == :splat
+            push "(function($splt) { for (var i = 0; i < $splt.length; i++) {"
+            push "if ($splt[i]['$===']($case)) { return true; }"
+            push "} return false; })(", expr(check[1]), ")"
+          else
+            if case_stmt[:cond]
+              call = s(:call, check, :===, s(:arglist, s(:js_tmp, '$case')))
+              push expr(call)
+            else
+              push js_truthy(check)
+            end
+          end
+        end
+
+        push ") {", process(body_code, @level), "}"
+      end
+
+      def when_checks
+        whens.children
+      end
+
+      def case_stmt
+        compiler.case_stmt
+      end
+
+      def body_code
+        body || s(:nil)
+      end
+    end
+  end
+end

data/lib/opal/nodes/class.rb

@@ -0,0 +1,42 @@
+require 'opal/nodes/module'
+
+module Opal
+  module Nodes
+    class ClassNode < ModuleNode
+      handle :class
+
+      children :cid, :sup, :body
+
+      def compile
+        name, base = name_and_base
+        helper :klass
+
+        push "(function($base, $super) {"
+        line "  function $#{name}(){};"
+        line "  var self = $#{name} = $klass($base, $super, '#{name}', $#{name});"
+
+        in_scope do
+          scope.name = name
+          add_temp "#{scope.proto} = self.$$proto"
+          add_temp "$scope = self.$$scope"
+
+          body_code = self.body_code
+          empty_line
+
+          line scope.to_vars
+          line body_code
+        end
+
+        line "})(", base, ", ", self.super_code, ")"
+      end
+
+      def super_code
+        sup ? expr(sup) : 'null'
+      end
+
+      def body_code
+        stmt(compiler.returns(body || s(:nil)))
+      end
+    end
+  end
+end

data/lib/opal/nodes/constants.rb

@@ -0,0 +1,78 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ConstNode < Base
+      handle :const
+
+      children :name
+
+      def compile
+        if name == :DATA and compiler.eof_content
+          push("$__END__")
+        else
+          push "$scope.get('#{name}')"
+        end
+      end
+    end
+
+    class ConstDeclarationNode < Base
+      handle :cdecl
+
+      children :name, :base
+
+      def compile
+        push expr(base)
+        wrap "$opal.cdecl($scope, '#{name}', ", ")"
+      end
+    end
+
+    class ConstAssignNode < Base
+      handle :casgn
+
+      children :base, :name, :value
+
+      def compile
+        push "$opal.casgn("
+        push expr(base)
+        push ", '#{name}', "
+        push expr(value)
+        push ")"
+      end
+    end
+
+    class ConstGetNode < Base
+      handle :colon2
+
+      children :base, :name
+
+      def compile
+        push "(("
+        push expr(base)
+        push ").$$scope.get('#{name}'))"
+      end
+    end
+
+    class TopConstNode < Base
+      handle :colon3
+
+      children :name
+
+      def compile
+        push "Opal.get('#{name}')"
+      end
+    end
+
+    class TopConstAssignNode < Base
+      handle :casgn3
+
+      children :name, :value
+
+      def compile
+        push "$opal.casgn($opal.Object, '#{name}', "
+        push expr(value)
+        push ")"
+      end
+    end
+  end
+end

data/lib/opal/nodes/def.rb

@@ -0,0 +1,157 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    # FIXME: needs rewrite
+    class DefNode < ScopeNode
+      handle :def
+
+      children :recvr, :mid, :args, :stmts
+
+      def compile
+        jsid = mid_to_jsid mid.to_s
+        params = nil
+        scope_name = nil
+
+        # opt args if last arg is sexp
+        opt = args.pop if Sexp === args.last
+
+        argc = args.length - 1
+
+        # block name (&block)
+        if args.last.to_s.start_with? '&'
+          block_name = variable(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 compiler.arity_check?
+          arity_code = arity_check(args, opt, uses_splat, block_name, mid)
+        end
+
+        in_scope 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 = stmt(compiler.returns(stmts))
+
+          add_temp 'self = this'
+
+          line "#{variable(splat)} = $slice.call(arguments, #{argc});" if splat
+
+          opt[1..-1].each do |o|
+            next if o[2][2] == :undefined
+            line "if (#{variable(o[1])} == null) {"
+            line '  ', expr(o)
+            line "}"
+          end if opt
+
+          # must do this after opt args incase opt arg uses yield
+          scope_name = scope.identity
+
+          if scope.uses_block?
+            add_temp "$iter = #{scope_name}.$$p"
+            add_temp "#{yielder} = $iter || nil"
+
+            line "#{scope_name}.$$p = null;"
+          end
+
+          unshift "\n#{current_indent}", scope.to_vars
+          line stmt_code
+
+          unshift arity_code if arity_code
+
+          unshift "var $zuper = $slice.call(arguments, 0);" if scope.uses_zuper
+
+          if scope.catch_return
+            unshift "try {\n"
+            line "} catch ($returner) { if ($returner === $opal.returner) { return $returner.$v }"
+            push " throw $returner; }"
+          end
+        end
+
+        unshift ") {"
+        unshift(params)
+        unshift "function("
+        unshift "#{scope_name} = " if scope_name
+        line "}"
+
+        if recvr
+          unshift '$opal.defs(', recv(recvr), ", '$#{mid}', "
+          push ')'
+        elsif scope.class? and %w(Object BasicObject).include?(scope.name)
+          wrap "$opal.defn(self, '$#{mid}', ", ')'
+        elsif scope.class_scope?
+          scope.methods << "$#{mid}"
+          unshift "#{scope.proto}#{jsid} = "
+        elsif scope.iter?
+          wrap "$opal.defn(self, '$#{mid}', ", ')'
+        elsif scope.type == :sclass
+          unshift "self.$$proto#{jsid} = "
+        elsif scope.top?
+          unshift "$opal.Object.$$proto#{jsid} = "
+        else
+          unshift "def#{jsid} = "
+        end
+
+        wrap '(', ", nil) && '#{mid}'" if expr?
+      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
+    end
+
+    # def args list
+    class ArgsNode < Base
+      handle :args
+
+      def compile
+        children.each_with_index do |child, idx|
+          next if child.to_s == '*'
+
+          child = child.to_sym
+          push ', ' unless idx == 0
+          child = variable(child)
+          scope.add_arg child.to_sym
+          push child.to_s
+        end
+      end
+    end
+  end
+end