opal 0.9.4 → 0.10.0.beta1

data/lib/opal/nodes/hash.rb

@@ -5,11 +5,17 @@ module Opal
     class HashNode < Base
       handle :hash
 
-      def keys_and_values
+      def extract_keys_and_values(pairs)
         keys, values = [], []
 
-        children.each_with_index do |obj, idx|
-          if idx.even?
+        pairs.each_with_index do |obj, idx|
+          if obj.type == :kwsplat
+            # obj is (:kwsplat, (:hash, (:key, value), ...))
+            kwsplat_pairs = obj[1].children
+            kwsplat_keys, kwsplat_values = extract_keys_and_values(kwsplat_pairs)
+            keys.concat(kwsplat_keys)
+            values.concat(kwsplat_values)
+          elsif idx.even?
             keys << obj
           else
             values << obj
@@ -24,7 +30,7 @@ module Opal
       end
 
       def compile
-        keys, values = keys_and_values
+        keys, values = extract_keys_and_values(children)
 
         if simple_keys? keys
           compile_hash2 keys, values

data/lib/opal/nodes/helpers.rb

@@ -23,6 +23,9 @@ module Opal
       # Doesn't take in account utf8
       BASIC_IDENTIFIER_RULES = /#{REGEXP_START}[$_a-z][$_a-z\d]*#{REGEXP_END}/i
 
+      # Defining a local function like Array may break everything
+      RESERVED_FUNCTION_NAMES = /#{REGEXP_START}(?:Array)#{REGEXP_END}/
+
 
       def property(name)
         valid_name?(name) ? ".#{name}" : "[#{name.inspect}]"
@@ -114,15 +117,15 @@ module Opal
         if sexp.type == :call
           mid = sexp[2]
           receiver_handler_class = (receiver = sexp[1]) && compiler.handlers[receiver.type]
-          
+
           # Only operator calls on the truthy_optimize? node classes should be optimized.
           # Monkey patch method calls might return 'self'/aka a bridged instance and need
           # the nil check - see discussion at https://github.com/opal/opal/pull/1097
           allow_optimization_on_type = Compiler::COMPARE.include?(mid.to_s) &&
             receiver_handler_class &&
             receiver_handler_class.truthy_optimize?
-          
-          if allow_optimization_on_type || 
+
+          if allow_optimization_on_type ||
             mid == :block_given? ||
             mid == :"=="
             expr(sexp)

data/lib/opal/nodes/inline_args.rb

@@ -0,0 +1,61 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    # def args list
+    class InlineArgs < Base
+      handle :inline_args
+
+      def compile
+        push(arg_names.join(', '))
+      end
+
+      def arg_names
+        done_kwargs = false
+
+        children.inject([]) do |result, child|
+          case child.type
+          when :kwarg, :kwoptarg, :kwrestarg
+            unless done_kwargs
+              done_kwargs = true
+              result << '$kwargs'
+            end
+            add_arg(child)
+          when :mlhs
+            tmp = scope.next_temp
+            result << tmp
+            scope.mlhs_mapping[child] = tmp
+          when :arg, :optarg
+            arg_name = variable(child[1]).to_s
+            if !child.meta[:inline] && arg_name[0] != '$'
+              arg_name = "$#{arg_name}"
+            end
+            result << arg_name
+            add_arg(child)
+          when :restarg
+            # To make function.length working
+            # in cases like def m(*rest)
+            tmp_arg_name = scope.next_temp + "_rest"
+            result << tmp_arg_name
+            add_arg(child)
+          else
+            raise "Unknown argument type #{child.inspect}"
+          end
+
+          result
+        end
+      end
+
+      # If the argument has a name,
+      # we should mark it as an argument for current scope
+      # Otherwise, these args will be interpreted
+      # in the child scope as local variables
+      def add_arg(arg)
+        if arg[1]
+          arg_name = variable(arg[1].to_sym)
+          scope.add_arg(arg_name)
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/iter.rb

@@ -1,46 +1,37 @@
-require 'opal/nodes/scope'
+require 'opal/nodes/node_with_args'
 
 module Opal
   module Nodes
-    class IterNode < ScopeNode
+    class IterNode < NodeWithArgs
       handle :iter
 
       children :args_sexp, :body_sexp
 
+      attr_accessor :block_arg, :shadow_args
+
       def compile
-        opt_args  = extract_opt_args
-        block_arg = extract_block_arg
-
-        # 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
+        inline_params = nil
+        extract_block_arg
+        extract_shadow_args
+        split_args
 
-        params = args_to_params(args[1..-1])
-        params << splat if splat
+        # require 'pry'; binding.pry
 
         to_vars = identity = body_code = nil
 
         in_scope do
+          inline_params = process(inline_args_sexp)
+
           identity = scope.identify!
           add_temp "self = #{identity}.$$s || this"
 
-          compile_args(args[1..-1], opt_args, params)
+          compile_shadow_args
 
-          if splat
-            scope.add_arg splat
-            push "#{splat} = $slice.call(arguments, #{len - 1});"
-          end
+          compile_inline_args
+          compile_post_args
 
-          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
+          compile_block_arg
+          compile_norm_args
 
           body_code = stmt(body)
           to_vars = scope.to_vars
@@ -50,86 +41,86 @@ module Opal
 
         unshift to_vars
 
-        unshift "(#{identity} = function(#{params.join ', '}){"
-        push "}, #{identity}.$$s = self, #{identity})"
+        unshift "(#{identity} = function(", inline_params, "){"
+        push "}, #{identity}.$$s = self,"
+        push " #{identity}.$$brk = $brk," if compiler.has_break?
+        push " #{identity})"
       end
 
-      def compile_args(args, opt_args, params)
-        args.each_with_index do |arg, idx|
-          if arg.type == :lasgn
-            arg = variable(arg[1])
+      def norm_args
+        @norm_args ||= args[1..-1].select { |arg| arg.type == :arg }
+      end
 
-            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
-            vars = {}
-            arg[1..-1].each_with_index do |_arg, _idx|
-              _arg = variable(_arg[1])
-              unless vars.has_key?(_arg) || params.include?(_arg)
-                vars[_arg] = "#{params[idx]}[#{_idx}]"
-              end
-            end
-            push "var #{ vars.map{|k, v| "#{k} = #{v}"}.join(', ') };"
-          else
-            raise "Bad block arg type"
-          end
+      def compile_norm_args
+        norm_args.each do |arg|
+          arg = variable(arg[1])
+          push "if (#{arg} == null) #{arg} = nil;"
         end
       end
 
-      # opt args are last (if present) and are a s(:block)
-      def extract_opt_args
-        if args.last.is_a?(Sexp) and args.last.type == :block
-          opt_args = args.pop
-          opt_args.shift
-          opt_args
+      def compile_block_arg
+        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
       end
 
-      # does this iter define a block_pass
       def extract_block_arg
-        if args.last.is_a?(Sexp) and args.last.type == :block_pass
-          block_arg = args.pop
-          block_arg = block_arg[1][1].to_sym
+        if args.is_a?(Sexp) && args.last.is_a?(Sexp) and args.last.type == :block_pass
+          self.block_arg = args.pop[1][1].to_sym
+        end
+      end
+
+      def compile_shadow_args
+        shadow_args.each do |shadow_arg|
+          scope.add_local(shadow_arg.last)
+        end
+      end
+
+      def extract_shadow_args
+        if args.is_a?(Sexp)
+          @shadow_args = []
+          args.children.each_with_index do |arg, idx|
+            if arg.type == :shadowarg
+              @shadow_args << args.delete(arg)
+            end
+          end
         end
       end
 
       def args
-        if Fixnum === args_sexp or args_sexp.nil?
-          s(:array)
-        elsif args_sexp.type == :lasgn
-          s(:array, args_sexp)
+        sexp = if Fixnum === args_sexp or args_sexp.nil?
+          s(:args)
+        elsif args_sexp.is_a?(Sexp) && args_sexp.type == :lasgn
+          s(:args, s(:arg, *args_sexp[1]))
         else
           args_sexp[1]
         end
+
+        # compacting _ arguments into a single one (only the first one leaves in the sexp)
+        caught_blank_argument = false
+
+        sexp.each_with_index do |part, idx|
+          if part.is_a?(Sexp) && part.last == :_
+            if caught_blank_argument
+              sexp.delete_at(idx)
+            end
+            caught_blank_argument = true
+          end
+        end
+
+        sexp
       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])
-            next if ref == :_ && result.include?(ref)
-            self.add_arg ref
-            result << ref
-          elsif arg[0] == :array
-            result << scope.next_temp
-          else
-            raise "Bad js_block_arg: #{arg[0]}"
-          end
-        end
-
-        result
+      def mlhs_args
+        scope.mlhs_mapping.keys
       end
     end
   end

data/lib/opal/nodes/logic.rb

@@ -40,8 +40,18 @@ module Opal
 
       def compile_iter
         error "break must be used as a statement" unless stmt?
-        push expr_or_nil(value)
-        wrap "return ($breaker.$v = ", ", $breaker)"
+        compiler.has_break!
+        line 'Opal.brk(', break_val, ', $brk)'
+      end
+
+      def break_val
+        if value.nil?
+          expr(s(:nil))
+        elsif children.size > 1
+          expr(s(:array, *children))
+        else
+          expr(value)
+        end
       end
     end
 

data/lib/opal/nodes/masgn.rb

@@ -3,8 +3,7 @@ require 'opal/nodes/base'
 module Opal
   module Nodes
     class MassAssignNode < Base
-      # TODO: does this work for cvars?? constants??
-      SIMPLE_ASSIGNMENT = [:lasgn, :iasgn, :lvar, :gasgn]
+      SIMPLE_ASSIGNMENT = [:lasgn, :iasgn, :lvar, :gasgn, :cdecl]
 
       handle :masgn
       children :lhs, :rhs

data/lib/opal/nodes/node_with_args.rb

@@ -0,0 +1,141 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    class NodeWithArgs < ScopeNode
+      attr_accessor :mlhs_args
+      attr_accessor :used_kwargs
+      attr_accessor :mlhs_mapping
+      attr_accessor :working_arguments
+      attr_writer :inline_args
+      attr_accessor :kwargs_initialized
+
+      attr_reader :inline_args, :post_args
+
+      def initialize(*)
+        super
+
+        @mlhs_args = {}
+        @used_kwargs = []
+        @mlhs_mapping = {}
+        @working_arguments = nil
+        @in_mlhs = false
+        @kwargs_initialized = false
+
+        @inline_args = []
+        @post_args = []
+
+        @post_args_started = false
+      end
+
+      def split_args
+        args = self.args[1..-1]
+        args.each_with_index do |arg, idx|
+          last_argument = (idx == args.length - 1)
+          case arg.type
+          when :arg, :mlhs, :kwarg, :kwoptarg, :kwrestarg
+            if @post_args_started
+              @post_args << arg
+            else
+              @inline_args << arg
+            end
+          when :restarg
+            @post_args_started = true
+            @post_args << arg
+          when :optarg
+            if args[idx, args.length].any? { |next_arg| next_arg.type != :optarg && next_arg.type != :restarg }
+              @post_args_started = true
+            end
+            # otherwise we have:
+            #   a. ... + optarg + [optargs]
+            #   b. ... + optarg + [optargs] + restarg
+            # and these cases are simple, we can handle args in inline mode
+
+            if @post_args_started
+              @post_args << arg
+            else
+              @inline_args << arg
+            end
+          end
+        end
+
+        inline_args.each do |inline_arg|
+          inline_arg.meta[:inline] = true
+        end
+
+        optimize_args!
+      end
+
+      def opt_args
+        @opt_args ||= args[1..-1].select { |arg| arg.first == :optarg }
+      end
+
+      def rest_arg
+        @rest_arg ||= args[1..-1].find { |arg| arg.first == :restarg }
+      end
+
+      def keyword_args
+        @keyword_args ||= args[1..-1].select do |arg|
+          [:kwarg, :kwoptarg, :kwrestarg].include? arg.first
+        end
+      end
+
+      def inline_args_sexp
+        s(:inline_args, *args[1..-1])
+      end
+
+      def post_args_sexp
+        s(:post_args, *post_args)
+      end
+
+      def compile_inline_args
+        inline_args.each do |inline_arg|
+          push process(inline_arg)
+        end
+      end
+
+      def compile_post_args
+        push process(post_args_sexp)
+      end
+
+      def compile_block_arg
+        if scope.uses_block?
+          scope_name  = scope.identity
+          yielder     = scope.block_name
+
+          add_temp "$iter = #{scope_name}.$$p"
+          add_temp "#{yielder} = $iter || nil"
+
+          line "#{scope_name}.$$p = null;"
+        end
+      end
+
+      def with_inline_args(args)
+        old_inline_args = inline_args
+        self.inline_args = args
+        yield
+        self.inline_args = old_inline_args
+      end
+
+      def in_mlhs
+        old_mlhs = @in_mlhs
+        @in_mlhs = true
+        yield
+        @in_mlhs = old_mlhs
+      end
+
+      def in_mlhs?
+        @in_mlhs
+      end
+
+      def optimize_args!
+        # Simple cases like def m(a,b,*rest) can be processed inline
+        if post_args.length == 1 && post_args.first.type == :restarg
+          rest_arg = post_args.pop
+          rest_arg.meta[:offset] = inline_args.length
+          inline_args << rest_arg
+        end
+      end
+    end
+  end
+end