opal 1.1.0 → 1.2.0

data/lib/opal/rewriters/forward_args.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ForwardArgs < Base
+      def on_forward_args(_node)
+        process(
+          s(:args, s(:forward_arg, :"$"))
+        )
+      end
+
+      def on_args(node)
+        if node.children.last && node.children.last.type == :forward_arg
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:restarg, '$fwd_rest'),
+              s(:blockarg, '$fwd_block')
+            ]
+          )
+        else
+          super
+        end
+      end
+
+      def on_send(node)
+        if node.children.last &&
+           node.children.last.class != Symbol &&
+           node.children.last.type == :forwarded_args
+
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:splat,
+                s(:lvar, '$fwd_rest')
+              ),
+              s(:block_pass,
+                s(:lvar, '$fwd_block')
+              )
+            ]
+          )
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/logical_operator_assignment.rb

@@ -20,7 +20,7 @@ module Opal
           get_node = lhs.updated(get_type)              # lhs
           condition_node = s(root_type, get_node, rhs)  # lhs || rhs
 
-          if get_type == :const && root_type == :or
+          if %i[const cvar].include?(get_type) && root_type == :or
             # defined?(lhs)
             defined_node = s(:defined?, get_node)
             # LHS = defined?(LHS) ? (LHS || rhs) : rhs
@@ -51,7 +51,10 @@ module Opal
       GlobalVariableHandler = GET_SET[:gvar, :gvasgn]
 
       # Takes    `@@lhs ||= rhs`
-      # Produces `@@lhs = @@lhs || rhs`
+      # Produces `@@lhs = defined?(@@lhs) ? (@@lhs || rhs) : rhs`
+      #
+      # Takes    `@@lhs &&= rhs`
+      # Produces `@@lhs = @@lhs && rhs`
       ClassVariableHandler = GET_SET[:cvar, :cvasgn]
 
       # Takes    `recvr.meth ||= rhs`

data/lib/opal/rewriters/opal_engine_check.rb

@@ -9,14 +9,12 @@ module Opal
         test, true_body, false_body = *node.children
 
         if skip_check_present?(test)
-          false_body = s(:nil)
+          process(true_body || s(:nil))
+        elsif skip_check_present_not?(test)
+          process(false_body || s(:nil))
+        else
+          super
         end
-
-        if skip_check_present_not?(test)
-          true_body = s(:nil)
-        end
-
-        node.updated(nil, process_all([test, true_body, false_body]))
       end
 
       def skip_check_present?(test)

data/lib/opal/rewriters/pattern_matching.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class PatternMatching < Base
+      def initialize
+        @depth = 0
+        super
+      end
+
+      # a => b
+      def on_match_pattern(node)
+        from, pat = *node
+
+        s(:begin,
+          s(:lvasgn, :"$pmvar", from),
+          s(:if,
+            convert_full_pattern(from, pat),
+            nil,
+            raise_no_matching_pattern_error(:"$pmvar")
+          )
+        )
+      end
+
+      # a in b
+      def on_match_pattern_p(node)
+        from, pat = *node
+
+        s(:if,
+          convert_full_pattern(from, pat),
+          s(:true),
+          s(:false)
+        )
+      end
+
+      # case a; in b; end
+      def on_case_match(node)
+        @depth += 1
+
+        cmvar = :"$cmvar#{@depth}"
+
+        from, *cases, els = *node
+
+        if els
+          process els
+        else
+          els = raise_no_matching_pattern_error(cmvar)
+        end
+
+        s(:begin,
+          s(:lvasgn, cmvar, from),
+          single_case_match(cmvar, *cases, els)
+        )
+      end
+
+      private
+
+      # raise NoMatchingPatternError, from
+      def raise_no_matching_pattern_error(from)
+        s(:send, nil, :raise,
+          s(:const, nil, :NoMatchingPatternError),
+          s(:lvar, from)
+        )
+      end
+
+      # in b
+      def single_case_match(from, *cases, els)
+        cas = cases.shift
+        pat, if_guard, body = *cas
+
+        pat = convert_full_pattern(from, pat)
+        if if_guard
+          guard, = *if_guard
+          case if_guard.type
+          when :if_guard
+            pat = s(:and, pat, guard)
+          when :unless_guard
+            pat = s(:and, pat, s(:send, guard, :!))
+          end
+        end
+
+        s(:if,
+          pat,
+          process(body),
+          if !cases.empty?
+            single_case_match(from, *cases, els)
+          elsif els != s(:empty_else)
+            els
+          end
+        )
+      end
+
+      def convert_full_pattern(from, pat)
+        if from.class == Symbol
+          from = s(:lvar, from)
+        end
+
+        converter = PatternConverter.new(pat)
+        converter.run!
+
+        # a, b, c = ::PatternMatching.(from, [...])
+        s(:masgn,
+          s(:mlhs,
+            *converter.variables
+          ),
+          s(:send,
+            s(:const, s(:cbase), :PatternMatching),
+            :call,
+            from,
+            converter.pattern,
+          )
+        )
+      end
+
+      class PatternConverter < ::Opal::Rewriters::Base
+        def initialize(pat)
+          @pat = pat
+          @variables = []
+        end
+
+        def run!
+          @outpat = process(@pat)
+        end
+
+        def pattern
+          @outpat
+        end
+
+        def variables
+          @variables.map { |i| s(:lvasgn, i) }
+        end
+
+        # a
+        def on_match_var(node)
+          var, = *node
+
+          @variables << var
+
+          s(:sym, :var)
+        end
+
+        # [...] => a
+        def on_match_as(node)
+          pat, save = *node
+
+          process(save)
+          array(s(:sym, :save), process(pat))
+        end
+
+        def on_literal(node)
+          array(s(:sym, :lit), node)
+        end
+
+        alias on_int on_literal
+        alias on_float on_literal
+        alias on_complex on_literal
+        alias on_rational on_literal
+        alias on_array on_literal
+        alias on_str on_literal
+        alias on_dstr on_literal
+        alias on_xstr on_literal
+        alias on_sym on_literal
+        alias on_irange on_literal
+        alias on_erange on_literal
+        alias on_const on_literal
+        alias on_regexp on_literal
+        alias on_lambda on_literal
+        alias on_begin on_literal
+
+        # ^a
+        def on_pin(node)
+          on_literal(node.children.first)
+        end
+
+        # *
+        def on_match_rest(node)
+          if node.children.empty?
+            array(s(:sym, :rest))
+          else
+            array(s(:sym, :rest), process(node.children.first))
+          end
+        end
+
+        # {} | []
+        def on_match_alt(node)
+          array(s(:sym, :any), *node.children.map(&method(:process)))
+        end
+
+        # MyStructName
+        def on_const_pattern(node)
+          array(s(:sym, :all), *node.children.map(&method(:process)))
+        end
+
+        # [0, 1, 2] or [*, 0, 1] or [0, 1, *]
+        def on_array_pattern(node, tail = false)
+          children = *node
+          children << s(:match_rest) if tail
+
+          fixed_size = true
+          array_size = 0
+
+          children = children.each do |i|
+            case i.type
+            when :match_rest
+              fixed_size = false
+            else
+              array_size += 1
+            end
+          end
+
+          array(
+            s(:sym, :array),
+            to_ast(fixed_size),
+            to_ast(array_size),
+            to_ast(children.map(&method(:process)))
+          )
+        end
+
+        # [0, 1, 2,]
+        def on_array_pattern_with_tail(node)
+          on_array_pattern(node, true)
+        end
+
+        # {a:, b:}
+        def on_hash_pattern(node)
+          children = *node
+
+          any_size = children.empty? ? to_ast(false) : to_ast(true)
+
+          children = children.map do |i|
+            case i.type
+            when :pair
+              array(i.children[0], process(i.children[1]))
+            when :match_var
+              array(s(:sym, i.children[0]), process(i))
+            when :match_nil_pattern
+              any_size = to_ast(false)
+              nil
+            when :match_rest
+              # Capturing rest?
+              if i.children.first
+                any_size = process(i.children.first)
+              else
+                any_size = to_ast(true)
+              end
+              nil
+            end
+          end.compact
+
+          array(s(:sym, :hash), any_size, array(*children))
+        end
+
+        # [*, a, b, *]
+        def on_find_pattern(node)
+          children = *node
+
+          children = children.map(&method(:process))
+
+          array(s(:sym, :find), array(*children))
+        end
+
+        private
+
+        def array(*args)
+          to_ast(args)
+        end
+
+        def to_ast(val)
+          case val
+          when Array
+            s(:array, *val)
+          when Integer
+            s(:int, val)
+          when true
+            s(:true)
+          when false
+            s(:false)
+          when nil
+            s(:nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/version.rb

@@ -3,5 +3,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/opal/corelib/array.rb

@@ -196,7 +196,7 @@ class Array < `Array`
         result = result.concat(converted);
       }
 
-      return toArraySubclass(result, #{self.class});
+      return result;
     }
   end
 
@@ -361,7 +361,7 @@ class Array < `Array`
       }
 
       result = self.slice(from, to);
-      return toArraySubclass(result, self.$class());
+      return result;
     }
 
     function $array_slice_index_length(self, index, length) {
@@ -394,7 +394,7 @@ class Array < `Array`
 
         result = self.slice(index, index + length);
       }
-      return toArraySubclass(result, self.$class());
+      return result;
     }
   }
 
@@ -883,7 +883,9 @@ class Array < `Array`
     self
   end
 
-  alias difference -
+  def difference(*arrays)
+    arrays.reduce(to_a.dup) { |a, b| a - b }
+  end
 
   def dig(idx, *idxs)
     item = self[idx]
@@ -1180,7 +1182,7 @@ class Array < `Array`
         level = $coerce_to(level, #{Integer}, 'to_int');
       }
 
-      return toArraySubclass(_flatten(self, level), #{self.class});
+      return _flatten(self, level);
     }
   end
 
@@ -1335,7 +1337,9 @@ class Array < `Array`
     }
   end
 
-  alias intersection &
+  def intersection(*arrays)
+    arrays.reduce(to_a.dup) { |a, b| a & b }
+  end
 
   def join(sep = nil)
     return '' if `self.length === 0`
@@ -2165,10 +2169,19 @@ class Array < `Array`
   end
 
   def to_a
-    self
+    %x{
+      if (self.$$class === Opal.Array) {
+        return self;
+      }
+      else {
+        return Opal.Array.$new(self);
+      }
+    }
   end
 
-  alias to_ary to_a
+  def to_ary
+    self
+  end
 
   def to_h(&block)
     array = self
@@ -2224,7 +2237,9 @@ class Array < `Array`
     result
   end
 
-  alias union |
+  def union(*arrays)
+    arrays.reduce(uniq) { |a, b| a | b }
+  end
 
   def uniq(&block)
     %x{
@@ -2248,7 +2263,7 @@ class Array < `Array`
         }
       }
 
-      return toArraySubclass(#{`hash`.values}, #{self.class});
+      return #{`hash`.values};
     }
   end
 
@@ -2276,12 +2291,23 @@ class Array < `Array`
 
   def unshift(*objects)
     %x{
-      for (var i = objects.length - 1; i >= 0; i--) {
-        self.unshift(objects[i]);
+      var selfLength = self.length
+      var objectsLength = objects.length
+      if (objectsLength == 0) return self;
+      var index = selfLength - objectsLength
+      for (var i = 0; i < objectsLength; i++) {
+        self.push(self[index + i])
+      }
+      var len = selfLength - 1
+      while (len - objectsLength >= 0) {
+        self[len] = self[len - objectsLength]
+        len--
+      }
+      for (var j = 0; j < objectsLength; j++) {
+        self[j] = objects[j]
       }
+      return self;
     }
-
-    self
   end
 
   alias prepend unshift
@@ -2332,12 +2358,8 @@ class Array < `Array`
         if (o.$$is_array) {
           continue;
         }
-        if (o.$$is_enumerator) {
-          if (o.$size() === Infinity) {
-            others[j] = o.$take(size);
-          } else {
-            others[j] = o.$to_a();
-          }
+        if (o.$$is_range || o.$$is_enumerator) {
+          others[j] = o.$take(size);
           continue;
         }
         others[j] = #{(