opal-cj 0.7.0.beta1

data/lib/opal/nodes/masgn.rb

@@ -0,0 +1,62 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class MassAssignNode < Base
+      handle :masgn
+
+      children :lhs, :rhs
+
+      def compile
+        tmp = scope.new_temp
+        len = 0 # how many rhs items are we sure we have
+
+        if rhs.type == :array
+          len = rhs.size - 1
+          push "#{tmp} = ", expr(rhs)
+        elsif rhs.type == :to_ary
+          push "#{tmp} = $opal.to_ary(", expr(rhs[1]), ")"
+        elsif rhs.type == :splat
+          push "(#{tmp} = ", expr(rhs[1]), ")['$to_a'] && !#{tmp}['$to_a'].$$stub ? (#{tmp} = #{tmp}['$to_a']())"
+          push " : (#{tmp}).$$is_array ? #{tmp} : (#{tmp} = [#{tmp}])"
+        else
+          raise "unsupported mlhs type"
+        end
+
+        lhs.children.each_with_index do |child, idx|
+          push ', '
+
+          if child.type == :splat
+            if part = child[1]
+              part = part.dup
+              part << s(:js_tmp, "$slice.call(#{tmp}, #{idx})")
+              push expr(part)
+            end
+          else
+            if idx >= len
+              assign = s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
+            else
+              assign = s(:js_tmp, "#{tmp}[#{idx}]")
+            end
+
+            part = child.dup
+            if child.type == :lasgn or child.type == :iasgn or child.type == :lvar or child.type == :gasgn
+              part << assign
+            elsif child.type == :call
+              part[2] = "#{part[2]}=".to_sym
+              part.last << assign
+            elsif child.type == :attrasgn
+              part.last << assign
+            else
+              raise "Bad lhs for masgn"
+            end
+
+            push expr(part)
+          end
+        end
+
+        scope.queue_temp tmp
+      end
+    end
+  end
+end

data/lib/opal/nodes/module.rb

@@ -0,0 +1,46 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    class ModuleNode < ScopeNode
+      handle :module
+
+      children :cid, :body
+
+      def compile
+        name, base = name_and_base
+        helper :module
+
+        push "(function($base) {"
+        line "  var self = $module($base, '#{name}');"
+
+        in_scope do
+          scope.name = name
+          add_temp "#{scope.proto} = self.$$proto"
+          add_temp '$scope = self.$$scope'
+
+          body_code = stmt(body || s(:nil))
+          empty_line
+
+          line scope.to_vars
+          line body_code
+          line scope.to_donate_methods
+        end
+
+        line "})(", base, ")"
+      end
+
+      def name_and_base
+        if cid.type == :const
+          [cid[1].to_s, 'self']
+        elsif cid.type == :colon2
+          [cid[2].to_s, expr(cid[1])]
+        elsif cid.type == :colon3
+          [cid[1].to_s, '$opal.Object']
+        else
+          raise "Bad receiver in module"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/rescue.rb

@@ -0,0 +1,135 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class RescueModNode < Base
+      handle :rescue_mod
+
+      children :lhs, :rhs
+
+      def body
+        stmt? ? lhs : compiler.returns(lhs)
+      end
+
+      def rescue_val
+        stmt? ? rhs : compiler.returns(rhs)
+      end
+
+      def compile
+        push "try {", expr(body), " } catch ($err) { ", expr(rescue_val), " }"
+
+        wrap '(function() {', '})()' unless stmt?
+      end
+    end
+
+    class EnsureNode < Base
+      handle :ensure
+
+      children :begn, :ensr
+
+      def compile
+        push "try {"
+        line compiler.process(body_sexp, @level)
+        line "} finally {"
+        line compiler.process(ensr_sexp, @level)
+        line "}"
+
+        wrap '(function() {', '; })()' if wrap_in_closure?
+      end
+
+      def body_sexp
+        wrap_in_closure? ? compiler.returns(begn) : begn
+      end
+
+      def ensr_sexp
+        ensr || s(:nil)
+      end
+
+      def wrap_in_closure?
+        recv? or expr?
+      end
+    end
+
+    class RescueNode < Base
+      handle :rescue
+
+      children :body
+
+      def compile
+        handled_else = false
+
+        push "try {"
+        line(indent { process(body_code, @level) })
+        line "} catch ($err) {"
+
+        children[1..-1].each_with_index do |child, idx|
+          handled_else = true unless child.type == :resbody
+
+          push "else " unless idx == 0
+          push(indent { process(child, @level) })
+        end
+
+        # if no resbodys capture our error, then rethrow
+        unless handled_else
+          push "else { throw $err; }"
+        end
+
+        line "}"
+
+        wrap '(function() { ', '})()' if expr?
+      end
+
+      def body_code
+        body.type == :resbody ? s(:nil) : body
+      end
+    end
+
+    class ResBodyNode < Base
+      handle :resbody
+
+      children :args, :body
+
+      def compile
+        push "if ("
+        if rescue_exprs.empty?
+          # if no expressions are given, then catch all errors
+          push "true"
+        else
+          push "$opal.$rescue($err, ["
+          rescue_exprs.each_with_index do |rexpr, idx|
+            push ', ' unless idx == 0
+            push expr(rexpr)
+          end
+          push "])"
+        end
+        push ") {"
+
+        if variable = rescue_variable
+          variable[2] = s(:js_tmp, '$err')
+          push expr(variable), ';'
+        end
+
+        line process(rescue_body, @level)
+        line "}"
+      end
+
+      def rescue_variable?(variable)
+        Sexp === variable and [:lasgn, :iasgn].include?(variable.type)
+      end
+
+      def rescue_variable
+        rescue_variable?(args.last) ? args.last.dup : nil
+      end
+
+      def rescue_exprs
+        exprs = args.dup
+        exprs.pop if rescue_variable?(exprs.last)
+        exprs.children
+      end
+
+      def rescue_body
+        body || s(:nil)
+      end
+    end
+  end
+end

data/lib/opal/nodes/runtime_helpers.rb

@@ -0,0 +1,45 @@
+require 'set'
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class RuntimeHelpers < Base
+      HELPERS = Set.new
+
+      children :recvr, :meth, :arglist
+
+      def self.compatible?(recvr, meth, arglist)
+        recvr == [:const, :Opal] and HELPERS.include?(meth.to_sym)
+      end
+
+      def self.helper(name, &block)
+        HELPERS << name
+        define_method("compile_#{name}", &block)
+      end
+
+      def compile
+        if HELPERS.include?(meth.to_sym)
+          __send__("compile_#{meth}")
+        else
+          raise "Helper not supported: #{meth}"
+        end
+      end
+
+      helper :truthy? do
+        unless sexp = arglist[1]
+          raise "truthy? requires an object"
+        end
+
+        js_truthy(sexp)
+      end
+
+      helper :falsy? do
+        unless sexp = arglist[1]
+          raise "falsy? requires an object"
+        end
+
+        js_falsy(sexp)
+      end
+    end
+  end
+end

data/lib/opal/nodes/scope.rb

@@ -0,0 +1,293 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ScopeNode < Base
+
+      # Every scope can have a parent scope
+      attr_accessor :parent
+
+      # The class or module name if this scope is a class scope
+      attr_accessor :name
+
+      # The given block name for a def scope
+      attr_accessor :block_name
+
+      attr_reader :scope_name
+      attr_reader :ivars
+      attr_reader :gvars
+
+      attr_accessor :mid
+
+      # true if singleton def, false otherwise
+      attr_accessor :defs
+
+      # used by modules to know what methods to donate to includees
+      attr_reader :methods
+
+      # uses parents super method
+      attr_accessor :uses_super
+      attr_accessor :uses_zuper
+
+      attr_accessor :catch_return
+
+      def initialize(*)
+        super
+
+        @locals   = []
+        @temps    = []
+        @args     = []
+        @ivars    = []
+        @gvars    = []
+        @parent   = nil
+        @queue    = []
+        @unique   = 'a'
+        @while_stack = []
+        @identity = nil
+        @defs     = nil
+
+        @methods = []
+
+        @uses_block = false
+
+        # used by classes to store all ivars used in direct def methods
+        @proto_ivars = []
+      end
+
+      def in_scope(&block)
+        indent do
+          @parent = compiler.scope
+          compiler.scope = self
+          block.call self
+          compiler.scope = @parent
+        end
+      end
+
+      # Returns true if this scope is a class/module body scope
+      def class_scope?
+        @type == :class or @type == :module
+      end
+
+      # Returns true if this is strictly a class scope
+      def class?
+        @type == :class
+      end
+
+      # True if this is a module scope
+      def module?
+        @type == :module
+      end
+
+      def sclass?
+        @type == :sclass
+      end
+
+      # Returns true if this is a top scope (main file body)
+      def top?
+        @type == :top
+      end
+
+      # True if a block/iter scope
+      def iter?
+        @type == :iter
+      end
+
+      def def?
+        @type == :def
+      end
+
+      # Is this a normal def method directly inside a class? This is
+      # used for optimizing ivars as we can set them to nil in the
+      # class body
+      def def_in_class?
+        !@defs && @type == :def && @parent && @parent.class?
+      end
+
+      # Inside a class or module scope, the javascript variable name returned
+      # by this function points to the classes' prototype. This is the target
+      # to where methods are actually added inside a class body.
+      def proto
+        "def"
+      end
+
+      # A scope donates its methods if it is a module, or the core Object
+      # class. Modules donate their methods to classes or objects they are
+      # included in. Object donates methods to bridged classes whose native
+      # prototypes do not actually inherit from Opal.Object.prototype.
+      def should_donate?
+        @type == :module
+      end
+
+      ##
+      # Vars to use inside each scope
+      def to_vars
+        vars = @temps.dup
+        vars.push(*@locals.map { |l| "#{l} = nil" })
+
+        iv = ivars.map do |ivar|
+          "if (self#{ivar} == null) self#{ivar} = nil;\n"
+        end
+
+        gv = gvars.map do |gvar|
+          "if ($gvars#{gvar} == null) $gvars#{gvar} = nil;\n"
+        end
+
+        indent = @compiler.parser_indent
+        str  = vars.empty? ? '' : "var #{vars.join ', '};\n"
+        str += "#{indent}#{iv.join indent}" unless ivars.empty?
+        str += "#{indent}#{gv.join indent}" unless gvars.empty?
+
+        if class? and !@proto_ivars.empty?
+          #raise "FIXME to_vars"
+          pvars = @proto_ivars.map { |i| "#{proto}#{i}"}.join(' = ')
+          result = "%s\n%s%s = nil;" % [str, indent, pvars]
+        else
+          result = str
+        end
+
+        fragment(result)
+      end
+
+      # Generates code for this module to donate methods
+      def to_donate_methods
+        if should_donate? and !@methods.empty?
+          fragment("%s;$opal.donate(self, [%s]);" % [@compiler.parser_indent, @methods.map(&:inspect).join(', ')])
+        else
+          fragment("")
+        end
+      end
+
+      def add_scope_ivar(ivar)
+        if def_in_class?
+          @parent.add_proto_ivar ivar
+        else
+          @ivars << ivar unless @ivars.include? ivar
+        end
+      end
+
+      def add_scope_gvar(gvar)
+        @gvars << gvar unless @gvars.include? gvar
+      end
+
+      def add_proto_ivar(ivar)
+        @proto_ivars << ivar unless @proto_ivars.include? ivar
+      end
+
+      def add_arg(arg)
+        @args << arg unless @args.include? arg
+        arg
+      end
+
+      def add_scope_local(local)
+        return if has_local? local
+
+        @locals << local
+      end
+
+      def has_local?(local)
+        return true if @locals.include? local or @args.include? local
+        return @parent.has_local?(local) if @parent and @type == :iter
+
+        false
+      end
+
+      def add_scope_temp(*tmps)
+        @temps.push(*tmps)
+      end
+
+      def has_temp?(tmp)
+        @temps.include? tmp
+      end
+
+      def new_temp
+        return @queue.pop unless @queue.empty?
+
+        tmp = next_temp
+        @temps << tmp
+        tmp
+      end
+
+      def next_temp
+        tmp = "$#{@unique}"
+        @unique = @unique.succ
+        tmp
+      end
+
+      def queue_temp(name)
+        @queue << name
+      end
+
+      def push_while
+        info = {}
+        @while_stack.push info
+        info
+      end
+
+      def pop_while
+        @while_stack.pop
+      end
+
+      def in_while?
+        !@while_stack.empty?
+      end
+
+      def uses_block!
+        if @type == :iter && @parent
+          @parent.uses_block!
+        else
+          @uses_block = true
+          identify!
+        end
+      end
+
+      def identify!
+        return @identity if @identity
+
+        @identity = @compiler.unique_temp
+        @parent.add_scope_temp @identity if @parent
+
+        @identity
+      end
+
+      def identity
+        @identity
+      end
+
+      def find_parent_def
+        scope = self
+        while scope = scope.parent
+          if scope.def?
+            return scope
+          end
+        end
+
+        nil
+      end
+
+      def get_super_chain
+        chain, scope, defn, mid = [], self, 'null', 'null'
+
+        while scope
+          if scope.type == :iter
+            chain << scope.identify!
+            scope = scope.parent if scope.parent
+
+          elsif scope.type == :def
+            defn = scope.identify!
+            mid  = "'#{scope.mid}'"
+            break
+
+          else
+            break
+          end
+        end
+
+        [chain, defn, mid]
+      end
+
+      def uses_block?
+        @uses_block
+      end
+    end
+  end
+end