opal 1.3.1 → 1.4.1

data/lib/opal/nodes/if.rb

@@ -10,10 +10,30 @@ module Opal
       children :test, :true_body, :false_body
 
       def compile
+        if should_compile_as_simple_expression?
+          if true_body == s(:true)
+            compile_with_binary_or
+          elsif false_body == s(:false)
+            compile_with_binary_and
+          else
+            compile_with_ternary
+          end
+        else
+          compile_with_if
+        end
+      end
+
+      def compile_with_if
         truthy = self.truthy
         falsy = self.falsy
 
-        push 'if (', js_truthy(test), ') {'
+        if falsy && !truthy
+          # Let's optimize a little bit `unless` calls.
+          push 'if (!', js_truthy(test), ') {'
+          falsy, truthy = truthy, falsy
+        else
+          push 'if (', js_truthy(test), ') {'
+        end
 
         # skip if-body if no truthy sexp
         indent { line stmt(truthy) } if truthy
@@ -30,29 +50,114 @@ module Opal
             line '}'
           end
         else
-          push '}'
+          line '}'
+
+          # This resolution isn't finite. Let's ensure this block
+          # always return something if we expect a return
+          line 'return nil;' if expects_expression?
         end
 
-        if needs_wrapper?
+        if expects_expression?
           if scope.await_encountered
-            wrap '(await (async function() {', '; return nil; })())'
+            wrap '(await (async function() {', '})())'
           else
-            wrap '(function() {', '; return nil; })()'
+            wrap '(function() {', '})()'
           end
         end
       end
 
       def truthy
-        needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
+        returnify(true_body)
       end
 
       def falsy
-        needs_wrapper? ? compiler.returns(false_body || s(:nil)) : false_body
+        returnify(false_body)
+      end
+
+      def returnify(body)
+        if expects_expression? && body
+          compiler.returns(body)
+        else
+          body
+        end
       end
 
-      def needs_wrapper?
+      def expects_expression?
         expr? || recv?
       end
+
+      # There was a particular case in the past, that when we
+      # expected an expression from if, we always had to closure
+      # it. This produced an ugly code that was hard to minify.
+      # This addition tries to make a few cases compiled with
+      # a ternary operator instead and possibly a binary operator
+      # even?
+      def should_compile_as_simple_expression?
+        expects_expression? && simple?(true_body) && simple?(false_body)
+      end
+
+      def compile_with_ternary
+        truthy = true_body
+        falsy = false_body
+
+        push '('
+
+        push js_truthy(test), ' ? '
+
+        push '(', expr(truthy || s(:nil)), ') : '
+        if !falsy || falsy.type == :if
+          push expr(falsy || s(:nil))
+        else
+          push '(', expr(falsy || s(:nil)), ')'
+        end
+
+        push ')'
+      end
+
+      def compile_with_binary_and
+        if sexp.meta[:do_js_truthy_on_true_body]
+          truthy = js_truthy(true_body || s(:nil))
+        else
+          truthy = expr(true_body || s(:nil))
+        end
+
+        push '('
+        push js_truthy(test), ' && '
+        push '(', truthy, ')'
+        push ')'
+      end
+
+      def compile_with_binary_or
+        if sexp.meta[:do_js_truthy_on_false_body]
+          falsy = js_truthy(false_body || s(:nil))
+        else
+          falsy = expr(false_body || s(:nil))
+        end
+
+        push '('
+        push js_truthy(test), ' || '
+        push '(', falsy, ')'
+        push ')'
+      end
+
+      # Let's ensure there are no control flow statements inside.
+      def simple?(body)
+        case body
+        when AST::Node
+          case body.type
+          when :return, :js_return, :break, :next, :redo, :retry
+            false
+          when :xstr
+            XStringNode.single_line?(
+              XStringNode.strip_empty_children(body.children)
+            )
+          else
+            body.children.all? { |i| simple?(i) }
+          end
+        else
+          true
+        end
+      end
     end
 
     class IFlipFlop < Base

data/lib/opal/nodes/iter.rb

@@ -19,13 +19,15 @@ module Opal
 
         in_scope do
           identity = scope.identify!
-          add_temp "self = #{identity}.$$s == null ? this : #{identity}.$$s"
 
           inline_params = process(inline_args)
 
           compile_arity_check
 
           body_code = stmt(returned_body)
+
+          add_temp "self = #{identity}.$$s == null ? this : #{identity}.$$s" if @define_self
+
           to_vars = scope.to_vars
 
           line body_code
@@ -40,16 +42,19 @@ module Opal
         unshift to_vars
 
         if await_encountered
-          unshift "(#{identity} = async function(", inline_params, '){'
+          unshift "async function #{identity}(", inline_params, '){'
         else
-          unshift "(#{identity} = function(", inline_params, '){'
+          unshift "function #{identity}(", inline_params, '){'
         end
-        push "}, #{identity}.$$s = self,"
-        push " #{identity}.$$brk = $brk," if contains_break?
-        push " #{identity}.$$arity = #{arity},"
+        push '}'
+
+        blockopts = []
+        blockopts << "$$arity: #{arity}"
+        blockopts << "$$s: #{scope.self}" if @define_self
+        blockopts << "$$brk: $brk" if contains_break?
 
         if compiler.arity_check?
-          push " #{identity}.$$parameters = #{parameters_code},"
+          blockopts << "$$parameters: #{parameters_code}"
         end
 
         # MRI expands a passed argument if the block:
@@ -61,24 +66,26 @@ module Opal
         # This flag on the method indicates that a block has a top level mlhs argument
         # which means that we have to expand passed array explicitly in runtime.
         if has_top_level_mlhs_arg?
-          push " #{identity}.$$has_top_level_mlhs_arg = true,"
+          blockopts << "$$has_top_level_mlhs_arg: true"
         end
 
         if has_trailing_comma_in_args?
-          push " #{identity}.$$has_trailing_comma_in_args = true,"
+          blockopts << "$$has_trailing_comma_in_args: true"
         end
 
-        push " #{identity})"
+        if blockopts.length == 1
+          push ", #{arity}"
+        elsif blockopts.length > 1
+          push ', {', blockopts.join(', '), '}'
+        end
+
+        scope.nesting if @define_nesting
+        scope.relative_access if @define_relative_access
       end
 
       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;"
-          line "if (#{block_arg}) #{scope_name}.$$p = null;"
+          scope.prepare_block
         end
       end
 

data/lib/opal/nodes/literal.rb

@@ -8,7 +8,11 @@ module Opal
       handle :true, :false, :self, :nil
 
       def compile
-        push type.to_s
+        if type == :self
+          push scope.self
+        else
+          push type.to_s
+        end
       end
 
       def self.truthy_optimize?
@@ -137,7 +141,9 @@ module Opal
       end
 
       def compile_dynamic_regexp
-        push 'Opal.regexp(['
+        helper :regexp
+
+        push '$regexp(['
         value.children.each_with_index do |v, index|
           push ', ' unless index.zero?
           push expr(v)
@@ -229,10 +235,18 @@ module Opal
       handle :dstr
 
       def compile
-        push '""'
+        if children.length > 1 && children.first.type == :str
+          skip_empty = true
+        else
+          push '""'
+        end
 
         children.each do |part|
-          push ' + '
+          if skip_empty
+            skip_empty = false
+          else
+            push ' + '
+          end
 
           if part.type == :str
             push expr(part)

data/lib/opal/nodes/logic.rb

@@ -104,7 +104,8 @@ module Opal
         if empty_splat?
           push '[]'
         else
-          push 'Opal.to_a(', recv(value), ')'
+          helper :to_a
+          push '$to_a(', recv(value), ')'
         end
       end
     end

data/lib/opal/nodes/masgn.rb

@@ -18,17 +18,11 @@ module Opal
           rhs_len = rhs.children.any? { |c| c.type == :splat } ? nil : rhs.children.size
           compile_masgn(lhs.children, array, rhs_len)
           push ", #{array}" # a mass assignment evaluates to the RHS
-        elsif rhs.type == :begin
-          retval = scope.new_temp
-          push "#{retval} = ", expr(rhs)
-          push ", #{array} = Opal.to_ary(#{retval})"
-          compile_masgn(lhs.children, array)
-          push ", #{retval}"
-          scope.queue_temp(retval)
         else
+          helper :to_ary
           retval = scope.new_temp
           push "#{retval} = ", expr(rhs)
-          push ", #{array} = Opal.to_ary(#{retval})"
+          push ", #{array} = $to_ary(#{retval})"
           compile_masgn(lhs.children, array)
           push ", #{retval}"
           scope.queue_temp(retval)
@@ -97,9 +91,10 @@ module Opal
         elsif child.type == :attrasgn
           part.last << assign
         elsif child.type == :mlhs
+          helper :to_ary
           # nested destructuring
           tmp = scope.new_temp
-          push ", (#{tmp} = Opal.to_ary(#{assign.children[0]})"
+          push ", (#{tmp} = $to_ary(#{assign.children[0]})"
           compile_masgn(child.children, tmp)
           push ')'
           scope.queue_temp(tmp)

data/lib/opal/nodes/module.rb

@@ -13,23 +13,32 @@ module Opal
         name, base = name_and_base
         helper :module
 
-        line "  var self = $module($base, '#{name}');"
-        in_scope do
-          scope.name = name
-          compile_body
-        end
-
-        if await_encountered
-          await_begin = '(await '
-          await_end = ')'
-          async = 'async '
-          parent.await_encountered = true
+        if body.nil?
+          # Simplified compile for empty body
+          if stmt?
+            unshift '$module(', base, ", '#{name}')"
+          else
+            unshift '($module(', base, ", '#{name}'), nil)"
+          end
         else
-          await_begin, await_end, async = '', '', ''
-        end
+          line "  var self = $module($base, '#{name}');"
+          in_scope do
+            scope.name = name
+            compile_body
+          end
+
+          if await_encountered
+            await_begin = '(await '
+            await_end = ')'
+            async = 'async '
+            parent.await_encountered = true
+          else
+            await_begin, await_end, async = '', '', ''
+          end
 
-        unshift "#{await_begin}(#{async}function($base, $parent_nesting) {"
-        line '})(', base, ", $nesting)#{await_end}"
+          unshift "#{await_begin}(#{async}function($base#{', $parent_nesting' if @define_nesting}) {"
+          line '})(', base, "#{', ' + scope.nesting if @define_nesting})#{await_end}"
+        end
       end
 
       private
@@ -39,18 +48,19 @@ module Opal
         base, name = cid.children
 
         if base.nil?
-          [name, '$nesting[0]']
+          [name, "#{scope.nesting}[0]"]
         else
           [name, expr(base)]
         end
       end
 
       def compile_body
-        add_temp '$nesting = [self].concat($parent_nesting)'
-
-        body_code = stmt(compiler.returns(body || s(:nil)))
+        body_code = stmt(compiler.returns(body))
         empty_line
 
+        add_temp "$nesting = [self].concat($parent_nesting)" if @define_nesting
+        add_temp '$$ = Opal.$r($nesting)' if @define_relative_access
+
         line scope.to_vars
         line body_code
       end

data/lib/opal/nodes/node_with_args.rb

@@ -29,13 +29,7 @@ module Opal
 
       def compile_block_arg
         if scope.uses_block?
-          scope_name  = scope.identity
-          yielder     = scope.block_name || '$yield'
-
-          add_temp "$iter = #{scope_name}.$$p"
-          add_temp "#{yielder} = $iter || nil"
-
-          line "if ($iter) #{scope_name}.$$p = null;"
+          scope.prepare_block
         end
       end
 

data/lib/opal/nodes/scope.rb

@@ -88,11 +88,6 @@ module Opal
         @type == :top
       end
 
-      # Traverses to the top scope.
-      def top_scope
-        top? ? self : parent.top_scope
-      end
-
       # True if a block/iter scope
       def iter?
         @type == :iter
@@ -141,19 +136,21 @@ module Opal
           "if ($gvars#{gvar} == null) $gvars#{gvar} = nil;\n"
         end
 
+        if class? && !@proto_ivars.empty?
+          vars << '$proto = self.$$prototype'
+        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? && !@proto_ivars.empty?
-          pvars = @proto_ivars.map { |i| "self.$$prototype#{i}" }.join(' = ')
-          result = "#{str}\n#{indent}#{pvars} = nil;"
-        else
-          result = str
+          pvars = @proto_ivars.map { |i| "$proto#{i}" }.join(' = ')
+          str = "#{str}\n#{indent}#{pvars} = nil;"
         end
 
-        fragment(result)
+        fragment(str)
       end
 
       def add_scope_ivar(ivar)
@@ -190,7 +187,8 @@ module Opal
       end
 
       def scope_locals
-        @locals | @args | (@parent && @type == :iter ? @parent.scope_locals : [])
+        locals = @locals | @args | (@parent && @type == :iter ? @parent.scope_locals : [])
+        locals.reject { |i| i.to_s.start_with?('$') }
       end
 
       def add_scope_temp(tmp)
@@ -251,10 +249,21 @@ module Opal
       def identify!(name = nil)
         return @identity if @identity
 
-        # Parent scope is the defining module/class
-        name ||= [(parent && (parent.name || parent.scope_name)), mid].compact.join('_')
-        @identity = @compiler.unique_temp(name)
-        @parent.add_scope_temp @identity if @parent
+        if valid_name? mid
+          # There are some special utf8 chars that can be used as valid JS
+          # identifiers, some examples:
+          #
+          # utf8_pond = 'ⵌ'
+          # utf8_question = 'ʔ̣'
+          # utf8_exclamation 'ǃ'
+          #
+          # For now we're just using $$, to maintain compatibility with older IEs.
+          @identity = "$$#{mid}"
+        else
+          # Parent scope is the defining module/class
+          name ||= [(parent && (parent.name || parent.scope_name)), mid].compact.join('_')
+          @identity = @compiler.unique_temp(name)
+        end
 
         @identity
       end
@@ -371,6 +380,36 @@ module Opal
         [prev, curr]
       end
 
+      # Returns 'self', but also ensures that the self variable is set
+      def self
+        @define_self = true
+        'self'
+      end
+
+      # Returns '$nesting', but also ensures we compile the nesting chain
+      def nesting
+        @define_nesting = true
+        '$nesting'
+      end
+
+      # Returns '$$', but also ensures we compile it
+      def relative_access
+        @define_relative_access = @define_nesting = true
+        '$$'
+      end
+
+      def prepare_block(block_name = nil)
+        scope_name = scope.identity
+        self.block_name = block_name if block_name
+
+        add_temp "#{self.block_name} = #{scope_name}.$$p || nil"
+
+        unless @block_prepared
+          line "delete #{scope_name}.$$p;"
+          @block_prepared = true
+        end
+      end
+
       attr_accessor :await_encountered
     end
   end

data/lib/opal/nodes/singleton_class.rb

@@ -13,14 +13,16 @@ module Opal
         push '(function(self, $parent_nesting) {'
 
         in_scope do
-          add_temp '$nesting = [self].concat($parent_nesting)'
-
           body_stmt = stmt(compiler.returns(body))
+
+          add_temp '$nesting = [self].concat($parent_nesting)' if @define_nesting
+          add_temp '$$ = Opal.$r($nesting)' if @define_relative_access
+
           line scope.to_vars
           line body_stmt
         end
 
-        line '})(Opal.get_singleton_class(', recv(object), '), $nesting)'
+        line '})(Opal.get_singleton_class(', recv(object), "), #{scope.nesting})"
       end
     end
   end

data/lib/opal/nodes/super.rb

@@ -70,14 +70,14 @@ module Opal
 
       def super_method_invocation
         helper :find_super
-        "$find_super(self, '#{method_id}', #{def_scope_identity}, #{defined_check_param}, #{allow_stubs})"
+        "$find_super(#{scope.self}, '#{method_id}', #{def_scope_identity}, #{defined_check_param}, #{allow_stubs})"
       end
 
       def super_block_invocation
         helper :find_block_super
         chain, cur_defn, mid = scope.super_chain
         trys = chain.map { |c| "#{c}.$$def" }.join(' || ')
-        "$find_block_super(self, #{mid}, (#{trys} || #{cur_defn}), #{defined_check_param}, #{implicit_arguments_param})"
+        "$find_block_super(#{scope.self}, #{mid}, (#{trys} || #{cur_defn}), #{defined_check_param}, #{implicit_arguments_param})"
       end
 
       def compile_method_body
@@ -153,7 +153,7 @@ module Opal
         unless iter.type == :iter
           # Need to support passing block up even if it's not referenced in this method at all
           scope.uses_block!
-          @iter = s(:js_tmp, '$iter')
+          @iter = s(:js_tmp, scope.block_name || '$yield')
         end
       end
 
@@ -179,28 +179,28 @@ module Opal
         same_arg_counter = Hash.new(0)
 
         def_scope.original_args.children.each do |sexp|
-          arg_name = sexp.meta[:arg_name]
+          lvar_name = sexp.children[0]
 
           case sexp.type
           when :arg, :optarg
-            arg_node = s(:lvar, arg_name)
+            arg_node = s(:lvar, lvar_name)
             #   def m(_, _)
             # is compiled to
             #   function $$m(_, __$2)
             # See Opal::Node::ArgsNode
-            if arg_name[0] == '_'
-              same_arg_counter[arg_name] += 1
-              arg_node = s(:js_tmp, "#{arg_name}_$#{same_arg_counter[arg_name]}") if same_arg_counter[arg_name] > 1
+            if lvar_name[0] == '_'
+              same_arg_counter[lvar_name] += 1
+              arg_node = s(:js_tmp, "#{lvar_name}_$#{same_arg_counter[lvar_name]}") if same_arg_counter[lvar_name] > 1
             end
-
             args << arg_node
           when :restarg
-            arg_node = arg_name ? s(:lvar, arg_name) : s(:js_tmp, '$rest_arg')
+            arg_node = lvar_name ? s(:lvar, lvar_name) : s(:js_tmp, '$rest_arg')
             args << s(:splat, arg_node)
           when :kwarg, :kwoptarg
-            kwargs << s(:pair, s(:sym, arg_name), s(:lvar, arg_name))
+            key_name = sexp.meta[:arg_name]
+            kwargs << s(:pair, s(:sym, key_name), s(:lvar, lvar_name))
           when :kwrestarg
-            arg_node = arg_name ? s(:lvar, arg_name) : s(:js_tmp, '$kw_rest_arg')
+            arg_node = lvar_name ? s(:lvar, lvar_name) : s(:js_tmp, '$kw_rest_arg')
             kwargs << s(:kwsplat, arg_node)
           end
         end