opal 0.4.4 → 0.5.0

data/lib/opal/nodes/if.rb

@@ -0,0 +1,60 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class IfNode < Base
+      handle :if
+
+      children :test, :true_body, :false_body
+
+      def compile
+        truthy, falsy = self.truthy, self.falsy
+
+        push "if ("
+
+        # optimize unless (we don't want a else() unless we need to)
+        if falsy and !truthy
+          truthy = falsy
+          falsy = nil
+          push js_falsy(test)
+        else
+          push js_truthy(test)
+        end
+
+        push ") {"
+
+        # skip if-body if no truthy sexp
+        indent { line stmt(truthy) } if truthy
+
+        if falsy
+          if falsy.type == :if
+            line "} else ", stmt(falsy)
+          else
+            indent do
+              line "} else {"
+              line stmt(falsy)
+            end
+
+            line "}"
+          end
+        else
+          push "}"
+        end
+
+        wrap "(function() {", "; return nil; })()" if needs_wrapper?
+      end
+
+      def truthy
+        needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
+      end
+
+      def falsy
+        needs_wrapper? ? compiler.returns(false_body || s(:nil)) : false_body
+      end
+
+      def needs_wrapper?
+        expr? or recv?
+      end
+    end
+  end
+end

data/lib/opal/nodes/iter.rb

@@ -0,0 +1,118 @@
+require 'opal/nodes/base_scope'
+
+module Opal
+  module Nodes
+    # FIXME: this needs a rewrite very urgently
+    class IterNode < BaseScopeNode
+      handle :iter
+
+      children :args_sexp, :body_sexp
+
+      def compile
+        # opt args are last (if present) and are a s(:block)
+        if args.last.is_a?(Sexp) and args.last.type == :block
+          opt_args = args.pop
+          opt_args.shift
+        end
+
+        # does this iter define a block_pass
+        if args.last.is_a?(Sexp) and args.last.type == :block_pass
+          block_arg = args.pop
+          block_arg = block_arg[1][1].to_sym
+        end
+
+        # find any splat args
+        if args.last.is_a?(Sexp) and args.last.type == :splat
+          splat = args.last[1][1]
+          args.pop
+          len = args.length
+        end
+
+        params = args_to_params(args[1..-1])
+        params << splat if splat
+
+        to_vars = identity = nil
+
+        in_scope(:iter) do
+          identity = scope.identify!
+          add_temp "self = #{identity}._s || this"
+
+
+          args[1..-1].each_with_index do |arg, idx|
+            if arg.type == :lasgn
+              arg = variable(arg[1])
+
+              if opt_args and current_opt = opt_args.find { |s| s[1] == arg.to_sym }
+                push "if (#{arg} == null) #{arg} = ", expr(current_opt[2]), ";"
+              else
+                push "if (#{arg} == null) #{arg} = nil;"
+              end
+            elsif arg.type == :array
+              arg[1..-1].each_with_index do |_arg, _idx|
+                _arg = variable(_arg[1])
+                push "#{_arg} = #{params[idx]}[#{_idx}];"
+              end
+            else
+              raise "Bad block arg type"
+            end
+          end
+
+          if splat
+            scope.add_arg splat
+            push "#{splat} = $slice.call(arguments, #{len - 1});"
+          end
+
+          if block_arg
+            scope.block_name = block_arg
+            scope.add_temp block_arg
+            scope_name = scope.identify!
+
+            line "#{block_arg} = #{scope_name}._p || nil, #{scope_name}._p = null;"
+          end
+
+          line stmt(body)
+          to_vars = scope.to_vars
+        end
+
+        unshift to_vars
+        unshift "function(#{params.join ', '}) {"
+        wrap "(#{identity} = ", "}, #{identity}._s = self, #{identity})"
+      end
+
+      def args
+        if Fixnum === args_sexp or args_sexp.nil?
+          s(:array)
+        elsif args_sexp.type == :lasgn
+          s(:array, args_sexp)
+        else
+          args_sexp[1]
+        end
+      end
+
+      def body
+        compiler.returns(body_sexp || s(:nil))
+      end
+
+      # Maps block args into array of jsid. Adds $ suffix to invalid js
+      # identifiers.
+      #
+      # s(:args, parts...) => ["a", "b", "break$"]
+      def args_to_params(sexp)
+        result = []
+        sexp.each do |arg|
+          if arg[0] == :lasgn
+            ref = variable(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
+    end
+  end
+end

data/lib/opal/nodes/literal.rb

@@ -0,0 +1,193 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ValueNode < Base
+      handle :true, :false, :self, :nil
+
+      def compile
+        # :self, :true, :false, :nil
+        push type.to_s
+      end
+    end
+
+    class LiteralNode < Base
+      children :value
+    end
+
+    class NumericNode < LiteralNode
+      handle :int, :float
+
+      def compile
+        push value.to_s
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class StringNode < LiteralNode
+      handle :str
+
+      def compile
+        push value.inspect
+      end
+    end
+
+    class SymbolNode < LiteralNode
+      handle :sym
+
+      def compile
+        push value.to_s.inspect
+      end
+    end
+
+    class RegexpNode < LiteralNode
+      handle :regexp
+
+      def compile
+        push((value == // ? /^/ : value).inspect)
+      end
+    end
+
+    class XStringNode < LiteralNode
+      handle :xstr
+
+      def needs_semicolon?
+        stmt? and !value.to_s.include?(';')
+      end
+
+      def compile
+        push value.to_s
+        push ';' if needs_semicolon?
+
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class DynamicStringNode < Base
+      handle :dstr
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push "("
+            push expr(part[1])
+            push ")"
+          elsif part.type == :str
+            push part[1].inspect
+          else
+            raise "Bad dstr part"
+          end
+
+          wrap '(', ')' if recv?
+        end
+      end
+    end
+
+    class DynamicSymbolNode < Base
+      handle :dsym
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push expr(s(:call, part.last, :to_s, s(:arglist)))
+          elsif part.type == :str
+            push part.last.inspect
+          else
+            raise "Bad dsym part"
+          end
+        end
+
+        wrap '(', ')'
+      end
+    end
+
+    class DynamicXStringNode < Base
+      handle :dxstr
+
+      def requires_semicolon(code)
+        stmt? and !code.include?(';')
+      end
+
+      def compile
+        needs_semicolon = false
+
+        children.each do |part|
+          if String === part
+            push part.to_s
+            needs_semicolon = true if requires_semicolon(part.to_s)
+          elsif part.type == :evstr
+            push expr(part[1])
+          elsif part.type == :str
+            push part.last.to_s
+            needs_semicolon = true if requires_semicolon(part.last.to_s)
+          else
+            raise "Bad dxstr part"
+          end
+        end
+
+        push ';' if needs_semicolon
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class DynamicRegexpNode < Base
+      handle :dregx
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :str
+            push part[1].inspect
+          else
+            push expr(part[1])
+          end
+        end
+
+        wrap '(new RegExp(', '))'
+      end
+    end
+
+    class ExclusiveRangeNode < Base
+      handle :dot2
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push "$range("
+        push expr(start)
+        push ", "
+        push expr(finish)
+        push ", false)"
+      end
+    end
+
+    class InclusiveRangeNode < Base
+      handle :dot3
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push "$range("
+        push expr(start)
+        push ", "
+        push expr(finish)
+        push ", true)"
+      end
+    end
+  end
+end

data/lib/opal/nodes/logic.rb

@@ -0,0 +1,211 @@
+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
+        expr_or_nil value
+      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.$return(', 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