opal-cj 0.7.0.beta1

data/lib/opal/nodes/arglist.rb

@@ -0,0 +1,56 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    # FIXME: needs rewrite
+    class ArglistNode < Base
+      handle :arglist
+
+      def compile
+        code, work = [], []
+
+        children.each do |current|
+          splat = current.first == :splat
+          arg   = expr(current)
+
+          if splat
+            if work.empty?
+              if code.empty?
+                code << fragment("[].concat(")
+                code << arg
+                code << fragment(")")
+              else
+                code += ".concat(#{arg})"
+              end
+            else
+              if code.empty?
+                code << [fragment("["), work, fragment("]")]
+              else
+                code << [fragment(".concat(["), work, fragment("])")]
+              end
+
+              code << [fragment(".concat("), arg, fragment(")")]
+            end
+
+            work = []
+          else
+            work << fragment(", ") unless work.empty?
+            work << arg
+          end
+        end
+
+        unless work.empty?
+          join = work
+
+          if code.empty?
+            code = join
+          else
+            code << fragment(".concat(") << join << fragment(")")
+          end
+        end
+
+        push(*code)
+      end
+    end
+  end
+end

data/lib/opal/nodes/array.rb

@@ -0,0 +1,54 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ArrayNode < Base
+      handle :array
+
+      def compile
+        return push('[]') if children.empty?
+
+        code, work = [], []
+
+        children.each do |child|
+          splat = child.type == :splat
+          part  = expr(child)
+
+          if splat
+            if work.empty?
+              if code.empty?
+                code << fragment("[].concat(") << part << fragment(")")
+              else
+                code << fragment(".concat(") << part << fragment(")")
+              end
+            else
+              if code.empty?
+                code << fragment("[") << work << fragment("]")
+              else
+                code << fragment(".concat([") << work << fragment("])")
+              end
+
+              code << fragment(".concat(") << part << fragment(")")
+            end
+            work = []
+          else
+            work << fragment(", ") unless work.empty?
+            work << part
+          end
+        end
+
+        unless work.empty?
+          join = [fragment("["), work, fragment("]")]
+
+          if code.empty?
+            code = join
+          else
+            code.push([fragment(".concat("), join, fragment(")")])
+          end
+        end
+
+        push code
+      end
+    end
+  end
+end

data/lib/opal/nodes/base.rb

@@ -0,0 +1,151 @@
+require 'opal/nodes/helpers'
+
+module Opal
+  module Nodes
+    class Base
+      include Helpers
+
+      def self.handlers
+        @handlers ||= {}
+      end
+
+      def self.handle(*types)
+        types.each do |type|
+          Base.handlers[type] = self
+        end
+      end
+
+      def self.children(*names)
+        names.each_with_index do |name, idx|
+          define_method(name) do
+            @sexp[idx + 1]
+          end
+        end
+      end
+
+      attr_reader :compiler, :type
+
+      def initialize(sexp, level, compiler)
+        @sexp = sexp
+        @type = sexp.type
+        @level = level
+        @compiler = compiler
+      end
+
+      def children
+        @sexp[1..-1]
+      end
+
+      def compile_to_fragments
+        return @fragments if defined?(@fragments)
+
+        @fragments = []
+        self.compile
+        @fragments
+      end
+
+      def compile
+        raise "Not Implemented"
+      end
+
+      def push(*strs)
+        strs.each do |str|
+          str = fragment(str) if str.is_a?(String)
+          @fragments << str
+        end
+      end
+
+      def unshift(*strs)
+        strs.reverse.each do |str|
+          str = fragment(str) if str.is_a?(String)
+          @fragments.unshift str
+        end
+      end
+
+      def wrap(pre, post)
+        unshift pre
+        push post
+      end
+
+      def fragment(str)
+        Opal::Fragment.new str, @sexp
+      end
+
+      def error(msg)
+        @compiler.error msg
+      end
+
+      def scope
+        @compiler.scope
+      end
+
+      def s(*args)
+        @compiler.s(*args)
+      end
+
+      def expr?
+        @level == :expr
+      end
+
+      def recv?
+        @level == :recv
+      end
+
+      def stmt?
+        @level == :stmt
+      end
+
+      def process(sexp, level = :expr)
+        @compiler.process sexp, level
+      end
+
+      def expr(sexp)
+        @compiler.process sexp, :expr
+      end
+
+      def recv(sexp)
+        @compiler.process sexp, :recv
+      end
+
+      def stmt(sexp)
+        @compiler.process sexp, :stmt
+      end
+
+      def expr_or_nil(sexp)
+        sexp ? expr(sexp) : "nil"
+      end
+
+      def add_local(name)
+        scope.add_scope_local name.to_sym
+      end
+
+      def add_ivar(name)
+        scope.add_scope_ivar name
+      end
+
+      def add_gvar(name)
+        scope.add_scope_gvar name
+      end
+
+      def add_temp(temp)
+        scope.add_scope_temp temp
+      end
+
+      def helper(name)
+        @compiler.helper name
+      end
+
+      def with_temp(&block)
+        @compiler.with_temp(&block)
+      end
+
+      def in_while?
+        @compiler.in_while?
+      end
+
+      def while_loop
+        @compiler.instance_variable_get(:@while_loop)
+      end
+    end
+  end
+end

data/lib/opal/nodes/call.rb

@@ -0,0 +1,283 @@
+require 'set'
+require 'opal/nodes/base'
+require 'opal/nodes/runtime_helpers'
+
+module Opal
+  module Nodes
+    class CallNode < Base
+      handle :call
+
+      children :recvr, :meth, :arglist, :iter
+
+      SPECIALS = {}
+
+      # Operators that get optimized by compiler
+      OPERATORS = { :+ => :plus, :- => :minus, :* => :times, :/ => :divide,
+                    :< => :lt, :<= => :le, :> => :gt, :>= => :ge }
+
+      def self.add_special(name, options = {}, &handler)
+        SPECIALS[name] = options
+        define_method("handle_#{name}", &handler)
+      end
+
+      def compile
+        # handle some methods specially
+        handle_special
+
+        # some special methods need to skip compilation
+        return unless compile_default?
+
+        compiler.method_calls << meth.to_sym
+
+        # if trying to access an lvar in irb mode
+        return compile_irb_var if using_irb?
+
+        default_compile
+      end
+
+      def default_compile
+
+        mid = mid_to_jsid meth.to_s
+
+        splat = arglist[1..-1].any? { |a| a.first == :splat }
+
+        if Sexp === arglist.last and arglist.last.type == :block_pass
+          block = arglist.pop
+        elsif iter
+          block = iter
+        end
+
+        blktmp  = scope.new_temp if block
+        tmprecv = scope.new_temp if splat || blktmp
+
+        # must do this after assigning temp variables
+        block = expr(block) if block
+
+        recv_code = recv(recv_sexp)
+        call_recv = s(:js_tmp, tmprecv || recv_code)
+
+        if blktmp and !splat
+          arglist.insert 1, call_recv
+        end
+
+        args = expr(arglist)
+
+        if tmprecv
+          push "(#{tmprecv} = ", recv_code, ")#{mid}"
+        else
+          push recv_code, mid
+        end
+
+        if blktmp
+          unshift "(#{blktmp} = "
+          push ", #{blktmp}.$$p = ", block, ", #{blktmp})"
+        end
+
+        if splat
+          push ".apply(", (tmprecv || recv_code), ", ", args, ")"
+        elsif blktmp
+          push ".call(", args, ")"
+        else
+          push "(", args, ")"
+        end
+
+        scope.queue_temp blktmp if blktmp
+      end
+
+      def recv_sexp
+        recvr || s(:self)
+      end
+
+      def attr_assignment?
+        @assignment ||= meth.to_s =~ /^[\da-z]+\=$/i
+      end
+
+      # Used to generate the code to use this sexp as an ivar var reference
+      def compile_irb_var
+        with_temp do |tmp|
+          lvar = variable(meth)
+          call = s(:call, s(:self), meth.intern, s(:arglist))
+          push "((#{tmp} = $opal.irb_vars.#{lvar}) == null ? ", expr(call), " : #{tmp})"
+        end
+      end
+
+      def compile_assignment
+        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
+
+      # a variable reference in irb mode in top scope might be a var ref,
+      # or it might be a method call
+      def using_irb?
+        @compiler.irb? and scope.top? and arglist == s(:arglist) and recvr.nil? and iter.nil?
+      end
+
+      # Handle "special" method calls, e.g. require(). Subclasses can override
+      # this method. If this method returns nil, then the method will continue
+      # to be generated by CallNode.
+      def handle_special
+        @compile_default = true
+
+        if SPECIALS.include? meth
+          @compile_default = false
+          __send__("handle_#{meth}")
+        elsif RuntimeHelpers.compatible?(recvr, meth, arglist)
+          @compile_default = false
+          push(RuntimeHelpers.new(@sexp, @level, @compiler).compile)
+        end
+      end
+
+      def compile_default!
+        @compile_default = true
+      end
+
+      def compile_default?
+        @compile_default
+      end
+
+      OPERATORS.each do |operator, name|
+        add_special(operator.to_sym) do
+          if compiler.inline_operators?
+            compiler.operator_helpers << operator.to_sym
+            lhs, rhs = expr(recvr), expr(arglist[1])
+
+            push fragment("$rb_#{name}(")
+            push lhs
+            push fragment(", ")
+            push rhs
+            push fragment(")")
+          else
+            compile_default!
+          end
+        end
+      end
+
+      add_special :require do
+        compile_default!
+        str = DependencyResolver.new(compiler, arglist[1]).resolve
+        compiler.requires << str unless str.nil?
+        push fragment('')
+      end
+
+      add_special :require_relative do
+        arg = arglist[1]
+        file = compiler.file
+        if arg[0] == :str
+          compiler.requires << arg[1]
+        end
+        push fragment("self.$require(#{file.inspect}+ '/../' + ")
+        push process(arglist)
+        push fragment(')')
+      end
+
+      add_special :autoload do
+        if scope.class_scope?
+          compile_default!
+          str = DependencyResolver.new(compiler, arglist[2]).resolve
+          compiler.requires << str unless str.nil?
+          push fragment('')
+        end
+      end
+
+      add_special :require_tree do
+        arg = arglist[1]
+        if arg[0] == :str
+          dir = File.dirname(compiler.file)
+          relative_path = arg[1]
+          full_path = Pathname(dir).join(relative_path).cleanpath.to_s
+          compiler.required_trees << full_path
+          arg[1] = full_path
+        end
+        compile_default!
+        push fragment('')
+      end
+
+      add_special :block_given? do
+        push compiler.handle_block_given_call @sexp
+      end
+
+      add_special :__callee__ do
+        if scope.def?
+          push fragment scope.mid.to_s.inspect
+        else
+          push fragment 'nil'
+        end
+      end
+
+      add_special :__method__ do
+        if scope.def?
+          push fragment scope.mid.to_s.inspect
+        else
+          push fragment 'nil'
+        end
+      end
+
+      add_special :debugger do
+        push fragment 'debugger'
+      end
+
+      class DependencyResolver
+        def initialize(compiler, sexp)
+          @compiler = compiler
+          @sexp = sexp
+        end
+
+        def resolve
+          handle_part @sexp
+        end
+
+        def handle_part(sexp)
+          type = sexp.type
+
+          if type == :str
+            return sexp[1]
+          elsif type == :call
+            _, recv, meth, args = sexp
+
+            parts = args[1..-1].map { |s| handle_part s }
+
+            if recv == [:const, :File]
+              if meth == :expand_path
+                return expand_path(*parts)
+              elsif meth == :join
+                return expand_path parts.join('/')
+              elsif meth == :dirname
+                return expand_path parts[0].split('/')[0...-1].join('/')
+              end
+            end
+          end
+
+          msg = "Cannot handle dynamic require"
+          case @compiler.dynamic_require_severity
+          when :error
+            @compiler.error msg, @sexp.line
+          when :warning
+            @compiler.warning msg, @sexp.line
+          end
+        end
+
+        def expand_path(path, base = '')
+          "#{base}/#{path}".split("/").inject([]) do |p, part|
+            if part == ''
+              # we had '//', so ignore
+            elsif part == '..'
+              p.pop
+            else
+              p << part
+            end
+
+            p
+          end.join "/"
+        end
+      end
+    end
+  end
+end