opal-wedge 0.9.0.dev

data/lib/opal/nodes/logic.rb

@@ -0,0 +1,217 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class NextNode < Base
+      handle :next
+
+      children :value
+
+      def compile
+        return push "continue;" if in_while?
+
+        push expr_or_nil(value)
+        wrap "return ", ";"
+      end
+    end
+
+    class BreakNode < Base
+      handle :break
+
+      children :value
+
+      def compile
+        if in_while?
+          compile_while
+        elsif scope.iter?
+          compile_iter
+        else
+          error "void value expression: cannot use break outside of iter/while"
+        end
+      end
+
+      def compile_while
+        if while_loop[:closure]
+          push "return ", expr_or_nil(value)
+        else
+          push "break;"
+        end
+      end
+
+      def compile_iter
+        error "break must be used as a statement" unless stmt?
+        push expr_or_nil(value)
+        wrap "return ($breaker.$v = ", ", $breaker)"
+      end
+    end
+
+    class RedoNode < Base
+      handle :redo
+
+      def compile
+        if in_while?
+          compile_while
+        elsif scope.iter?
+          compile_iter
+        else
+          push "REDO()"
+        end
+      end
+
+      def compile_while
+        while_loop[:use_redo] = true
+        push "#{while_loop[:redo_var]} = true"
+      end
+
+      def compile_iter
+        push "return #{scope.identity}.apply(null, $slice.call(arguments))"
+      end
+    end
+
+    class NotNode < Base
+      handle :not
+
+      children :value
+
+      def compile
+        with_temp do |tmp|
+          push expr(value)
+          wrap "(#{tmp} = ", ", (#{tmp} === nil || #{tmp} === false))"
+        end
+      end
+    end
+
+    class SplatNode < Base
+      handle :splat
+
+      children :value
+
+      def empty_splat?
+        value == [:nil] or value == [:paren, [:nil]]
+      end
+
+      def compile
+        if empty_splat?
+          push '[]'
+        elsif value.type == :sym
+          push '[', expr(value), ']'
+        else
+          push recv(value)
+        end
+      end
+    end
+
+    class OrNode < Base
+      handle :or
+
+      children :lhs, :rhs
+
+      def compile
+        with_temp do |tmp|
+          push "(((#{tmp} = "
+          push expr(lhs)
+          push ") !== false && #{tmp} !== nil) ? #{tmp} : "
+          push expr(rhs)
+          push ")"
+        end
+      end
+    end
+
+    class AndNode < Base
+      handle :and
+
+      children :lhs, :rhs
+
+      def compile
+        truthy_opt = nil
+
+        with_temp do |tmp|
+          if truthy_opt = js_truthy_optimize(lhs)
+            push "((#{tmp} = ", truthy_opt
+            push ") ? "
+            push expr(rhs)
+            push " : #{tmp})"
+          else
+            push "(#{tmp} = "
+            push expr(lhs)
+            push ", #{tmp} !== false && #{tmp} !== nil ?"
+            push expr(rhs)
+            push " : #{tmp})"
+          end
+        end
+      end
+    end
+
+    class ReturnNode < Base
+      handle :return
+
+      children :value
+
+      def return_val
+        if value.nil?
+          expr(s(:nil))
+        elsif children.size > 1
+          expr(s(:array, *children))
+        else
+          expr(value)
+        end
+      end
+
+      def return_in_iter?
+        if scope.iter? and parent_def = scope.find_parent_def
+          parent_def
+        end
+      end
+
+      def return_expr_in_def?
+        return scope if expr? and scope.def?
+      end
+
+      def scope_to_catch_return
+        return_in_iter? or return_expr_in_def?
+      end
+
+      def compile
+        if def_scope = scope_to_catch_return
+          def_scope.catch_return = true
+          push 'Opal.ret(', return_val, ')'
+        elsif stmt?
+          push 'return ', return_val
+        else
+          raise SyntaxError, "void value expression: cannot return as an expression"
+        end
+      end
+    end
+
+    class JSReturnNode < Base
+      handle :js_return
+
+      children :value
+
+      def compile
+        push "return "
+        push expr(value)
+      end
+    end
+
+    class JSTempNode < Base
+      handle :js_tmp
+
+      children :value
+
+      def compile
+        push value.to_s
+      end
+    end
+
+    class BlockPassNode < Base
+      handle :block_pass
+
+      children :value
+
+      def compile
+        push expr(s(:call, value, :to_proc, s(:arglist)))
+      end
+    end
+  end
+end

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,45 @@
+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
+        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,143 @@
+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_code = (body.type == :resbody ? s(:nil) : body)
+
+        if !stmt?
+          compiler.returns body_code
+        else
+          body_code
+        end
+      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_code = (body || s(:nil))
+        body_code = compiler.returns(body_code) if !stmt?
+        body_code
+      end
+    end
+  end
+end