opal 0.10.6 → 0.11.0.rc1

data/lib/opal/nodes/defs.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'opal/nodes/def'
+
+module Opal
+  module Nodes
+    class DefsNode < DefNode
+      handle :defs
+      children :recvr, :mid, :args, :stmts
+
+      def extract_block_arg
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            recvr,
+            mid,
+            s(:args, *regular_args),
+            stmts
+          ])
+        end
+      end
+
+      def wrap_with_definition
+        unshift "Opal.defs(", expr(recvr), ", '$#{mid}', "
+        push ")"
+      end
+    end
+  end
+end

data/lib/opal/nodes/for.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -5,44 +6,70 @@ module Opal
     class ForNode < Base
       handle :for
 
-      children :value, :args_sexp, :body_sexp
+      children :arg, :value, :body_sexp
 
       def compile
+        # All variables that are used for iterating
+        # must be available outside of the for loop
+        plain_arg_names.each do |arg_name|
+          add_local arg_name
+        end
+
         with_temp do |loop_var|
-          if args_sexp.type == :array
-            assign = s(:masgn, args_sexp)
-            assign << s(:to_ary, s(:js_tmp, loop_var))
+          if arg.type == :mlhs
+            masgn_source_sexp = s(:js_tmp, loop_var)
+            assign = s(:masgn, arg, masgn_source_sexp)
           else
-            assign = args_sexp << s(:js_tmp, loop_var)
+            assign = arg << s(:js_tmp, loop_var)
           end
 
           if body_sexp
-            if body_sexp.first == :block
-              body_sexp.insert 1, assign
-              assign = body_sexp
-            else
-              assign = s(:block, assign, body_sexp)
-            end
+            assign = s(:begin, assign, body_sexp)
           end
 
-          assign.children.each do |sexp|
-            case sexp[0]
-            when :lasgn
-              add_local sexp[1]
-            when :masgn
-              if sexp[1][0] == :array
-                sexp[1][1].each do |sexp|
-                  add_local sexp[1] if sexp[0] == :lasgn
-                end
-              end
-            end
+          locals_in_for_body.each do |lvar|
+            add_local lvar
           end
 
-          iter = s(:iter, s(:lasgn, loop_var), assign)
-          sexp = s(:call, value, :each, s(:arglist), iter)
-          push expr(sexp)
+          # block_sexp is a sexp of our for loop
+          # converted to "value.each { |arg| body_sexp }"
+          block_sexp = s(:send, value, :each,
+            s(:iter, s(:args, s(:arg, loop_var)), assign)
+          )
+          push expr(block_sexp)
         end
       end
+
+      def plain_arg_names(node = arg)
+        case node.type
+        when :lvasgn
+          node.children
+        when :mlhs
+          node.children.flat_map { |mlhs_arg| plain_arg_names(mlhs_arg) }
+        else
+          []
+        end
+      end
+
+      class LocalsFinder < ::Parser::AST::Processor
+        attr_reader :lvasgns
+
+        def initialize
+          @lvasgns = Set.new
+        end
+
+        def on_lvasgn(node)
+          name, _value = *node
+          self.lvasgns << name
+          super
+        end
+      end
+
+      def locals_in_for_body
+        finder = LocalsFinder.new
+        finder.process(body_sexp)
+        finder.lvasgns.to_a
+      end
     end
   end
 end

data/lib/opal/nodes/hash.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -12,39 +13,16 @@ module Opal
         @has_kwsplat = false
         @keys = []
         @values = []
-      end
 
-      # Splits keys/values/kwsplats
-      #
-      # hash like { **{ nested: 1 }, d: 2 }
-      # is represetned by sexp:
-      # (:hash,
-      #   (:kwsplat,
-      #     (:hash,
-      #       (:sym, :nested),
-      #       (:int, 1)
-      #     )
-      #   ),
-      #   (:sym, :d),
-      #   (:int, 2),
-      # )
-      # So k/v pairs and kwsplats can be mixed in any order.
-      def extract_kv_pairs_and_kwsplats
-        found_key = false
-
-        children.each do |obj|
-          if obj.type == :kwsplat
-            self.has_kwsplat = true
-          elsif found_key
-            values << obj
-            found_key = false
-          else
-            keys << obj
-            found_key = true
+        children.each do |child|
+          case child.type
+          when :kwsplat
+            @has_kwsplat = true
+          when :pair
+            @keys << child.children[0]
+            @values << child.children[1]
           end
         end
-
-        [keys, values]
       end
 
       def simple_keys?
@@ -52,8 +30,6 @@ module Opal
       end
 
       def compile
-        extract_kv_pairs_and_kwsplats
-
         if has_kwsplat
           compile_merge
         elsif simple_keys?
@@ -103,9 +79,10 @@ module Opal
       def compile_hash
         helper :hash
 
-        children.each_with_index do |child, idx|
+        children.each_with_index do |pair, idx|
+          key, value = pair.children
           push ', ' unless idx == 0
-          push expr(child)
+          push expr(key), ', ', expr(value)
         end
 
         wrap '$hash(', ')'
@@ -118,7 +95,7 @@ module Opal
         helper :hash2
 
         keys.size.times do |idx|
-          key = keys[idx][1].to_s.inspect
+          key = keys[idx].children[0].to_s.inspect
           hash_keys << key unless hash_obj.include? key
           hash_obj[key] = expr(values[idx])
         end

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
@@ -100,8 +53,8 @@ module Opal
       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"
@@ -114,9 +67,9 @@ module Opal
       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
@@ -134,6 +87,26 @@ module Opal
           [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