opal 0.10.0 → 0.11.0

data/lib/opal/nodes/helpers.rb

@@ -1,62 +1,15 @@
+# frozen_string_literal: true
 require 'opal/regexp_anchors'
 
 module Opal
   module Nodes
     module Helpers
-
-      # Reserved javascript keywords - we cannot create variables with the
-      # same name (ref: http://stackoverflow.com/a/9337272/601782)
-      ES51_RESERVED_WORD = /#{REGEXP_START}(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)#{REGEXP_END}/
-
-      # ES3 reserved words that aren’t ES5.1 reserved words
-      ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/
-
-      # Prototype special properties.
-      PROTO_SPECIAL_PROPS = /#{REGEXP_START}(?:constructor|displayName|__proto__|__parent__|__noSuchMethod__|__count__)#{REGEXP_END}/
-
-      # Prototype special methods.
-      PROTO_SPECIAL_METHODS = /#{REGEXP_START}(?:hasOwnProperty|valueOf)#{REGEXP_END}/
-
-      # Immutable properties of the global object
-      IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/
-
-      # 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}]"
       end
 
       def valid_name?(name)
-        BASIC_IDENTIFIER_RULES =~ name and not(
-          ES51_RESERVED_WORD          =~ name or
-          ES3_RESERVED_WORD_EXCLUSIVE =~ name or
-          IMMUTABLE_PROPS             =~ name
-        )
-      end
-
-      def variable(name)
-        valid_name?(name.to_s) ? name : "#{name}$"
-      end
-
-      def valid_ivar_name?(name)
-        not (PROTO_SPECIAL_PROPS =~ name or PROTO_SPECIAL_METHODS =~ name)
-      end
-
-      def ivar(name)
-        valid_ivar_name?(name.to_s) ? name : "#{name}$"
-      end
-
-      # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
-      # are valid in javascript. A $ suffix is added to non-valid names.
-      # varibales
-      def lvar_to_js(var)
-        var = "#{var}$" unless valid_name? var.to_s
-        var.to_sym
+        Opal::Rewriters::JsReservedWords.valid_name?(name)
       end
 
       # Converts a ruby method name into its javascript equivalent for
@@ -94,29 +47,27 @@ module Opal
           return optimize
         end
 
-        with_temp do |tmp|
-          [fragment("((#{tmp} = "), expr(sexp), fragment(") !== nil && #{tmp} != null && (!#{tmp}.$$is_boolean || #{tmp} == true))")]
-        end
+        helper :truthy
+        [fragment("$truthy("),expr(sexp),fragment(")")]
       end
 
       def js_falsy(sexp)
-        if sexp.type == :call
-          mid = sexp[2]
+        if sexp.type == :send
+          mid = sexp.children[1]
           if mid == :block_given?
             scope.uses_block!
             return "#{scope.block_name} === nil"
           end
         end
 
-        with_temp do |tmp|
-          [fragment("((#{tmp} = "), expr(sexp), fragment(") === nil || #{tmp} == null || (#{tmp}.$$is_boolean && #{tmp} == false))")]
-        end
+        helper :falsy
+        [fragment("$falsy("),expr(sexp),fragment(")")]
       end
 
       def js_truthy_optimize(sexp)
-        if sexp.type == :call
-          mid = sexp[2]
-          receiver_handler_class = (receiver = sexp[1]) && compiler.handlers[receiver.type]
+        if sexp.type == :send
+          mid = sexp.children[1]
+          receiver_handler_class = (receiver = sexp.children[0]) && 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
@@ -130,10 +81,28 @@ module Opal
             mid == :"=="
             expr(sexp)
           end
-        elsif [:lvar, :self].include? sexp.type
-          [expr(sexp.dup), fragment(" !== false && "), expr(sexp.dup), fragment(" !== nil && "), expr(sexp.dup), fragment(" != null")]
         end
       end
+
+      # Usefule for safe-operator calls: foo&.bar / foo&.bar ||= baz / ...
+      #
+      # @param recvr [sexp_pushable] The receiver of the call that will be
+      #        stored in a temporary variable
+      # @yields receiver_temp [String] the name of the temporary variable
+      #         holding the ref to the original receiver, inside the block
+      #         an expr() should be pushed.
+      #
+      def conditional_send(recvr)
+        # temporary variable that stores method receiver
+        receiver_temp = scope.new_temp
+        push "#{receiver_temp} = ", recvr
+
+        # execute the sexp only if the receiver isn't nil
+        push ", (#{receiver_temp} === nil || #{receiver_temp} == null) ? nil : "
+        yield receiver_temp
+        wrap '(', ')'
+      end
+
     end
   end
 end

data/lib/opal/nodes/if.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -7,29 +8,9 @@ module Opal
 
       children :test, :true_body, :false_body
 
-      RUBY_ENGINE_CHECK = [:call, [:const, :RUBY_ENGINE],
-                              :==, [:arglist, [:str, "opal"]]]
-
-      RUBY_ENGINE_CHECK_NOT = [:call, [:const, :RUBY_ENGINE],
-                              :!=, [:arglist, [:str, "opal"]]]
-
-      RUBY_PLATFORM_CHECK = [:call, [:const, :RUBY_PLATFORM],
-                              :==, [:arglist, [:str, "opal"]]]
-
-      RUBY_PLATFORM_CHECK_NOT = [:call, [:const, :RUBY_PLATFORM],
-                              :!=, [:arglist, [:str, "opal"]]]
-
       def compile
         truthy, falsy = self.truthy, self.falsy
 
-        if skip_check_present?
-          falsy = nil
-        end
-
-        if skip_check_present_not?
-          truthy = nil
-        end
-
         push "if (", js_truthy(test), ") {"
 
         # skip if-body if no truthy sexp
@@ -53,18 +34,6 @@ module Opal
         wrap "(function() {", "; return nil; })()" if needs_wrapper?
       end
 
-      # pre-processing only effects falsy blocks. If engine is
-      # opal, then falsy block gets generated as normal. Unless
-      # engine is opal then that code gets generated as the
-      # falsy block
-      def skip_check_present?
-        test == RUBY_ENGINE_CHECK or test == RUBY_PLATFORM_CHECK
-      end
-
-      def skip_check_present_not?
-        test == RUBY_ENGINE_CHECK_NOT or test == RUBY_PLATFORM_CHECK_NOT
-      end
-
       def truthy
         needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
       end
@@ -77,5 +46,25 @@ module Opal
         expr? or recv?
       end
     end
+
+    class IFlipFlop < Base
+      handle :iflipflop
+
+      def compile
+        # Unsupported
+        # Always compiles to 'true' to not break generated JS
+        push 'true'
+      end
+    end
+
+    class EFlipFlop < Base
+      handle :eflipflop
+
+      def compile
+        # Unsupported
+        # Always compiles to 'true' to not break generated JS
+        push 'true'
+      end
+    end
   end
 end

data/lib/opal/nodes/inline_args.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -13,33 +14,33 @@ module Opal
       def arg_names
         done_kwargs = false
 
-        children.inject([]) do |result, child|
-          case child.type
+        children.inject([]) do |result, arg|
+          case arg.type
           when :kwarg, :kwoptarg, :kwrestarg
             unless done_kwargs
               done_kwargs = true
               result << '$kwargs'
             end
-            add_arg(child)
+            add_arg(arg)
           when :mlhs
             tmp = scope.next_temp
             result << tmp
-            scope.mlhs_mapping[child] = tmp
+            scope.mlhs_mapping[arg] = tmp
           when :arg, :optarg
-            arg_name = variable(child[1]).to_s
-            if !child.meta[:inline] && arg_name[0] != '$'
+            arg_name, _ = *arg
+            if !arg.meta[:inline] && arg_name[0] != '$'
               arg_name = "$#{arg_name}"
             end
             result << arg_name
-            add_arg(child)
+            add_arg(arg)
           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)
+            add_arg(arg)
           else
-            raise "Unknown argument type #{child.inspect}"
+            raise "Unknown argument type #{arg.inspect}"
           end
 
           result
@@ -51,10 +52,8 @@ module Opal
       # 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
+        arg_name, _ = *arg
+        scope.add_arg(arg_name) if arg_name
       end
     end
   end

data/lib/opal/nodes/iter.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
 require 'opal/nodes/node_with_args'
+require 'opal/rewriters/break_finder'
 
 module Opal
   module Nodes
     class IterNode < NodeWithArgs
       handle :iter
 
-      children :args_sexp, :body_sexp
+      children :args, :body
 
       attr_accessor :block_arg, :shadow_args
 
@@ -13,6 +15,7 @@ module Opal
         inline_params = nil
         extract_block_arg
         extract_shadow_args
+        extract_underscore_args
         split_args
 
         to_vars = identity = body_code = nil
@@ -33,7 +36,7 @@ module Opal
             compile_arity_check
           end
 
-          body_code = stmt(body)
+          body_code = stmt(returned_body)
           to_vars = scope.to_vars
         end
 
@@ -43,7 +46,7 @@ module Opal
 
         unshift "(#{identity} = function(", inline_params, "){"
         push "}, #{identity}.$$s = self,"
-        push " #{identity}.$$brk = $brk," if compiler.has_break?
+        push " #{identity}.$$brk = $brk," if contains_break?
         push " #{identity}.$$arity = #{arity},"
 
         if compiler.arity_check?
@@ -70,76 +73,89 @@ module Opal
       end
 
       def norm_args
-        @norm_args ||= args[1..-1].select { |arg| arg.type == :arg }
+        @norm_args ||= args.children.select { |arg| arg.type == :arg }
       end
 
       def compile_norm_args
         norm_args.each do |arg|
-          arg = variable(arg[1])
-          push "if (#{arg} == null) #{arg} = nil;"
+          arg_name, _ = *arg
+          push "if (#{arg_name} == null) #{arg_name} = nil;"
         end
       end
 
       def compile_block_arg
         if block_arg
-          block_arg = variable(self.block_arg.to_s)
           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;"
+          line "#{block_arg} = #{scope_name}.$$p || nil;"
+          line "if (#{block_arg}) #{scope_name}.$$p = null;"
         end
       end
 
       def extract_block_arg
-        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
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            s(:args, *regular_args),
+            body
+          ])
         end
       end
 
       def compile_shadow_args
         shadow_args.each do |shadow_arg|
-          scope.add_local(shadow_arg.last)
+          arg_name = shadow_arg.children[0]
+          scope.locals << arg_name
+          scope.add_arg(arg_name)
         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
+        @shadow_args = []
+        valid_args = []
+        return unless args
+
+        args.children.each_with_index do |arg, idx|
+          if arg.type == :shadowarg
+            @shadow_args << arg
+          else
+            valid_args << arg
           end
         end
-      end
 
-      def args
-        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
+        @sexp = @sexp.updated(nil, [
+          args.updated(nil, valid_args),
+          body
+        ])
+      end
 
-        # compacting _ arguments into a single one (only the first one leaves in the sexp)
+      def extract_underscore_args
+        valid_args = []
         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)
+        args.children.each do |arg|
+          arg_name = arg.children.first
+          if arg_name == :_
+            unless caught_blank_argument
+              caught_blank_argument = true
+              valid_args << arg
             end
-            caught_blank_argument = true
+          else
+            valid_args << arg
           end
         end
 
-        sexp
+        @sexp = @sexp.updated(nil, [
+          args.updated(nil, valid_args),
+          body
+        ])
       end
 
-      def body
-        compiler.returns(body_sexp || s(:nil))
+      def returned_body
+        compiler.returns(body || s(:nil))
       end
 
       def mlhs_args
@@ -151,7 +167,10 @@ module Opal
       end
 
       def has_trailing_comma_in_args?
-        args.meta[:has_trailing_comma]
+        if args.loc && args.loc.expression
+          args_source = args.loc.expression.source
+          args_source.match(/,\s*\|/)
+        end
       end
 
       # Returns code used in debug mode to check arity of method call
@@ -180,6 +199,12 @@ module Opal
           line "}"
         end
       end
+
+      def contains_break?
+        finder = Opal::Rewriters::BreakFinder.new
+        finder.process(@sexp)
+        finder.found_break?
+      end
     end
   end
 end