opal 1.4.0.alpha1 → 1.5.0.rc1

data/lib/opal/nodes/masgn.rb

@@ -11,24 +11,22 @@ module Opal
       children :lhs, :rhs
 
       def compile
-        array = scope.new_temp
-
-        if rhs.type == :array
-          push "#{array} = ", expr(rhs)
-          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
-        else
-          helper :to_ary
-          retval = scope.new_temp
-          push "#{retval} = ", expr(rhs)
-          push ", #{array} = $to_ary(#{retval})"
-          compile_masgn(lhs.children, array)
-          push ", #{retval}"
-          scope.queue_temp(retval)
+        with_temp do |array|
+          if rhs.type == :array
+            push "#{array} = ", expr(rhs)
+            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
+          else
+            helper :to_ary
+            with_temp do |retval|
+              push "#{retval} = ", expr(rhs)
+              push ", #{array} = $to_ary(#{retval})"
+              compile_masgn(lhs.children, array)
+              push ", #{retval}"
+            end
+          end
         end
-
-        scope.queue_temp(array)
       end
 
       # 'len' is how many rhs items are we sure we have

data/lib/opal/nodes/node_with_args/shortcuts.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Opal
+  module Nodes
+    class NodeWithArgs < ScopeNode
+      # Shortcuts for the simplest kinds of methods
+      Shortcut = Struct.new(:name, :for, :when, :transform) do
+        def match?(node)
+          node.instance_exec(&self.when)
+        end
+
+        def compile(node)
+          node.helper name
+          node.instance_exec(&transform)
+        end
+      end
+
+      @shortcuts = []
+      @shortcuts_for = {}
+      def self.define_shortcut(name, **kwargs, &block)
+        kwargs[:for] ||= :def
+        @shortcuts << Shortcut.new(name, kwargs[:for], kwargs[:when], block)
+      end
+
+      def self.shortcuts_for(node_type)
+        @shortcuts_for[node_type] ||=
+          @shortcuts.select do |shortcut|
+            [node_type, :*].include? shortcut.for
+          end
+      end
+
+      def compile_body_or_shortcut
+        # The shortcuts don't check arity. If we want to check arity,
+        # we can't use them.
+        return compile_body if compiler.arity_check?
+
+        node_type = is_a?(DefNode) ? :def : :iter
+
+        NodeWithArgs.shortcuts_for(node_type).each do |shortcut|
+          if shortcut.match?(self)
+            if ENV['OPAL_DEBUG_SHORTCUTS']
+              node_desc = node_type == :def ? "def #{mid}" : "iter"
+              warn "* shortcut #{shortcut.name} used for #{node_desc}"
+            end
+
+            return shortcut.compile(self)
+          end
+        end
+
+        compile_body
+      end
+
+      # Shortcut definitions
+      # --------------------
+
+      # def a; self; end
+      define_shortcut :return_self, when: -> { stmts.type == :self } do
+        push '$return_self'
+      end
+
+      def simple_value?(node = stmts)
+        %i[true false nil int float str sym].include?(node.type)
+      end
+
+      # def a; 123; end
+      define_shortcut :return_val, for: :*, when: -> { simple_value? } do
+        push '$return_val(', expr(stmts), ')'
+      end
+
+      # def a; @x; end
+      define_shortcut :return_ivar, when: -> { stmts.type == :ivar } do
+        name = stmts.children.first.to_s[1..-1].to_sym
+        push '$return_ivar(', expr(stmts.updated(:sym, [name])), ')'
+      end
+
+      # def a; @x = 5; end
+      define_shortcut :assign_ivar, when: -> {
+        stmts.type == :ivasgn &&
+          inline_args.children.length == 1 &&
+          inline_args.children.last.type == :arg &&
+          stmts.children.last.type == :lvar &&
+          stmts.children.last.children.last == inline_args.children.last.children.last
+      } do
+        name = stmts.children.first.to_s[1..-1].to_sym
+        name = expr(stmts.updated(:sym, [name]))
+        push '$assign_ivar(', name, ')'
+      end
+
+      # def a(x); @x = x; end
+      define_shortcut :assign_ivar_val, when: -> {
+        stmts.type == :ivasgn &&
+          simple_value?(stmts.children.last)
+      } do
+        name = stmts.children.first.to_s[1..-1].to_sym
+        name = expr(stmts.updated(:sym, [name]))
+        push '$assign_ivar_val(', name, ', ', expr(stmts.children.last), ')'
+      end
+    end
+  end
+end

data/lib/opal/nodes/node_with_args.rb

@@ -2,6 +2,7 @@
 
 require 'opal/nodes/scope'
 require 'opal/nodes/args/parameters'
+require 'opal/nodes/node_with_args/shortcuts'
 
 module Opal
   module Nodes

data/lib/opal/nodes/super.rb

@@ -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

data/lib/opal/nodes/top.rb

@@ -14,14 +14,22 @@ module Opal
 
       def compile
         compiler.top_scope = self
+        compiler.dynamic_cache_result = true if sexp.meta[:dynamic_cache_result]
 
         push version_comment
 
-        in_scope do
-          if body == s(:nil)
-            # A shortpath for empty (stub?) modules.
-            line 'return Opal.nil;'
+        helper :return_val if compiler.eof_content
+
+        if body == s(:nil)
+          # A shortpath for empty (stub?) modules.
+          if compiler.requirable? || compiler.esm? || compiler.eval?
+            unshift 'Opal.return_val(Opal.nil); '
+            definition
           else
+            unshift 'Opal.nil; '
+          end
+        else
+          in_scope do
             line '"use strict";' if compiler.use_strict?
 
             body_code = stmt(stmts)
@@ -47,20 +55,28 @@ module Opal
 
             line body_code
           end
+
+          opening
+          definition
+          closing
+        end
+      end
+
+      def definition
+        if compiler.requirable?
+          unshift "Opal.modules[#{Opal::Compiler.module_name(compiler.file).inspect}] = "
+        elsif compiler.esm?
+          unshift 'export default '
         end
-        opening
-        closing
       end
 
       def opening
         async_prefix = "async " if await_encountered
 
         if compiler.requirable?
-          unshift "Opal.modules[#{Opal::Compiler.module_name(compiler.file).inspect}] = #{async_prefix}function(Opal) {"
+          unshift "#{async_prefix}function(Opal) {"
         elsif compiler.eval?
           unshift "(#{async_prefix}function(Opal, self) {"
-        elsif compiler.esm?
-          unshift "export default Opal.queue(#{async_prefix}function(Opal) {"
         else
           unshift "Opal.queue(#{async_prefix}function(Opal) {"
         end
@@ -108,7 +124,7 @@ module Opal
       def compile_end_construct
         if content = compiler.eof_content
           line 'var $__END__ = Opal.Object.$new();'
-          line "$__END__.$read = function() { return #{content.inspect}; };"
+          line "$__END__.$read = $return_val(#{content.inspect});"
         end
       end
 

data/lib/opal/nodes/x_string.rb

@@ -8,9 +8,9 @@ module Opal
       def compile
         @should_add_semicolon = false
         unpacked_children = unpack_return(children)
-        stripped_children = strip_empty_children(unpacked_children)
+        stripped_children = XStringNode.strip_empty_children(unpacked_children)
 
-        if single_line?(stripped_children)
+        if XStringNode.single_line?(stripped_children)
           # If it's a single line we'll try to:
           #
           # - strip empty lines
@@ -30,6 +30,31 @@ module Opal
         push ';' if @should_add_semicolon
       end
 
+      # Check if there's only one child or if they're all part of
+      # the same line (e.g. because of interpolations)
+      def self.single_line?(children)
+        (children.size == 1) || children.none? do |c|
+          c.type == :str && c.loc.expression.source.end_with?("\n")
+        end
+      end
+
+      # Will remove empty :str lines coming from cosmetic newlines in x-strings
+      #
+      # @example
+      #   # this will generate two additional empty
+      #   # children before and after `foo()`
+      #   %x{
+      #     foo()
+      #   }
+      def self.strip_empty_children(children)
+        children = children.dup
+        empty_line = ->(child) { child.nil? || (child.type == :str && child.loc.expression.source.rstrip.empty?) }
+
+        children.shift while children.any? && empty_line[children.first]
+        children.pop while children.any? && empty_line[children.last]
+
+        children
+      end
 
       private
 
@@ -97,14 +122,6 @@ module Opal
         last_value
       end
 
-      # Check if there's only one child or if they're all part of
-      # the same line (e.g. because of interpolations)
-      def single_line?(children)
-        (children.size == 1) || children.none? do |c|
-          c.type == :str && c.loc.expression.source.end_with?("\n")
-        end
-      end
-
       # A case for manually created :js_return statement in Compiler#returns
       # Since we need to take original source of :str we have to use raw source
       # so we need to combine "return" with "raw_source"
@@ -119,24 +136,6 @@ module Opal
 
         children
       end
-
-      # Will remove empty :str lines coming from cosmetic newlines in x-strings
-      #
-      # @example
-      #   # this will generate two additional empty
-      #   # children before and after `foo()`
-      #   %x{
-      #     foo()
-      #   }
-      def strip_empty_children(children)
-        children = children.dup
-        empty_line = ->(child) { child.nil? || (child.type == :str && child.loc.expression.source.rstrip.empty?) }
-
-        children.shift while children.any? && empty_line[children.first]
-        children.pop while children.any? && empty_line[children.last]
-
-        children
-      end
     end
   end
 end

data/lib/opal/nodes.rb

@@ -5,7 +5,6 @@ require 'opal/nodes/literal'
 require 'opal/nodes/variables'
 require 'opal/nodes/constants'
 require 'opal/nodes/call'
-require 'opal/nodes/csend'
 require 'opal/nodes/call_special'
 require 'opal/nodes/module'
 require 'opal/nodes/class'

data/lib/opal/parser/default_config.rb

@@ -29,8 +29,9 @@ module Opal
       end
 
       def parse(source_buffer)
-        parsed = super
-        rewriten = rewrite(parsed)
+        parsed = super || ::Opal::AST::Node.new(:nil)
+        wrapped = ::Opal::AST::Node.new(:top, [parsed])
+        rewriten = rewrite(wrapped)
         rewriten
       end
 

data/lib/opal/repl.rb

@@ -164,7 +164,7 @@ module Opal
       load_opal
       raise e
     rescue EOFError, Errno::EPIPE
-      exit $?.exitstatus
+      exit $?.nil? ? 0 : $?.exitstatus
     end
 
     def readline

data/lib/opal/rewriter.rb

@@ -2,7 +2,6 @@
 
 require 'opal/rewriters/opal_engine_check'
 require 'opal/rewriters/for_rewriter'
-require 'opal/rewriters/explicit_writer_return'
 require 'opal/rewriters/js_reserved_words'
 require 'opal/rewriters/block_to_iter'
 require 'opal/rewriters/dot_js_syntax'
@@ -19,6 +18,8 @@ require 'opal/rewriters/forward_args'
 
 module Opal
   class Rewriter
+    @disabled = false
+
     class << self
       def list
         @list ||= []
@@ -32,15 +33,21 @@ module Opal
         list.delete(rewriter)
       end
 
-      def disable
-        @disabled = true
+      def disable(except: nil)
+        old_disabled = @disabled
+        @disabled = except || true
         yield
       ensure
-        @disabled = false
+        @disabled = old_disabled
       end
 
       def disabled?
-        @disabled if defined?(@disabled)
+        @disabled == true
+      end
+
+      def rewritter_disabled?(rewriter)
+        return false if @disabled == false
+        @disabled != rewriter
       end
     end
 
@@ -54,7 +61,6 @@ module Opal
     use Rewriters::JsReservedWords
     use Rewriters::LogicalOperatorAssignment
     use Rewriters::BinaryOperatorAssignment
-    use Rewriters::ExplicitWriterReturn
     use Rewriters::Hashes::KeyDuplicatesRewriter
     use Rewriters::ReturnableLogic
     use Rewriters::DumpArgs
@@ -69,6 +75,7 @@ module Opal
       return @sexp if self.class.disabled?
 
       self.class.list.each do |rewriter_class|
+        next if self.class.rewritter_disabled?(rewriter_class)
         rewriter = rewriter_class.new
         @sexp = rewriter.process(@sexp)
       end

data/lib/opal/rewriters/base.rb

@@ -51,7 +51,6 @@ module Opal
       end
 
       alias on_iter       process_regular_node
-      alias on_top        process_regular_node
       alias on_zsuper     process_regular_node
       alias on_jscall     on_send
       alias on_jsattr     process_regular_node
@@ -124,6 +123,18 @@ module Opal
         error.location = current_node.loc if current_node
         raise error
       end
+
+      def on_top(node)
+        node = process_regular_node(node)
+        node.meta[:dynamic_cache_result] = true if @dynamic_cache_result
+        node
+      end
+
+      # Called when a given transformation is deemed to be dynamic, so
+      # that cache is conditionally disabled for a given file.
+      def dynamic!
+        @dynamic_cache_result = true
+      end
     end
   end
 end

data/lib/opal/rewriters/rubyspec/filters_rewriter.rb

@@ -36,6 +36,7 @@ module Opal
         _recvr, method_name, *args = *node
 
         if rubyspec_dsl?(method_name)
+          dynamic!
           spec_name, _ = *args.first
           begin
             @specs_stack.push(spec_name)

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.4.0.alpha1'
+  VERSION = '1.5.0.rc1'
 end

data/opal/corelib/array.rb

@@ -441,20 +441,18 @@ class ::Array < `Array`
   end
 
   def []=(index, value, extra = undefined)
+    data = nil
     %x{
       var i, size = self.length;
-    }
 
-    if ::Range === index
-      data = if ::Array === value
-               value.to_a
-             elsif value.respond_to? :to_ary
-               value.to_ary.to_a
-             else
-               [value]
-             end
+      if (index.$$is_range) {
+        if (value.$$is_array)
+          data = #{value.to_a};
+        else if (#{value.respond_to? :to_ary})
+          data = #{value.to_ary.to_a};
+        else
+          data = [value];
 
-      %x{
         var exclude = index.excl,
             from    = index.begin === nil ? 0 : $coerce_to(index.begin, Opal.Integer, 'to_int'),
             to      = index.end === nil ? -1 : $coerce_to(index.end, Opal.Integer, 'to_int');
@@ -489,24 +487,21 @@ class ::Array < `Array`
         }
 
         return value;
-      }
-    else
-      if `extra === undefined`
-        length = 1
-      else
-        length = value
-        value  = extra
-
-        data = if ::Array === value
-                 value.to_a
-               elsif value.respond_to? :to_ary
-                 value.to_ary.to_a
-               else
-                 [value]
-               end
-      end
+      } else {
+        if (extra === undefined) {
+          #{length = 1}
+        } else {
+          length = value;
+          value  = extra;
+
+          if (value.$$is_array)
+            data = #{value.to_a};
+          else if (#{value.respond_to? :to_ary})
+            data = #{value.to_ary.to_a};
+          else
+            data = [value];
+        }
 
-      %x{
         var old;
 
         index  = $coerce_to(index, #{::Integer}, 'to_int');
@@ -540,7 +535,7 @@ class ::Array < `Array`
 
         return value;
       }
-    end
+    }
   end
 
   def any?(pattern = undefined, &block)

data/opal/corelib/binding.rb

@@ -1,8 +1,9 @@
 class ::Binding
   # @private
-  def initialize(jseval, scope_variables, receiver, source_location)
+  def initialize(jseval, scope_variables = [], receiver = undefined, source_location = nil)
     @jseval, @scope_variables, @receiver, @source_location = \
       jseval, scope_variables, receiver, source_location
+    receiver = js_eval('self') unless `typeof receiver !== undefined`
   end
 
   def js_eval(*args)
@@ -20,7 +21,10 @@ class ::Binding
   end
 
   def local_variable_set(symbol, value)
-    js_eval(symbol, value)
+    `Opal.Binding.tmp_value = value`
+    js_eval("#{symbol} = Opal.Binding.tmp_value")
+    `delete Opal.Binding.tmp_value`
+    value
   end
 
   def local_variables
@@ -46,5 +50,11 @@ module ::Kernel
   end
 end
 
-TOPLEVEL_BINDING = binding
-`#{TOPLEVEL_BINDING}.source_location = ["<main>", 0]`
+TOPLEVEL_BINDING = ::Binding.new(
+  %x{
+    function(js) {
+      return (new Function("self", "return " + js))(self);
+    }
+  },
+  [], self, ['<main>', 0]
+)

data/opal/corelib/constants.rb

@@ -1,9 +1,9 @@
 ::RUBY_PLATFORM       = 'opal'
 ::RUBY_ENGINE         = 'opal'
 ::RUBY_VERSION        = '3.1.0'
-::RUBY_ENGINE_VERSION = '1.4.0.alpha1'
-::RUBY_RELEASE_DATE   = '2021-12-21'
+::RUBY_ENGINE_VERSION = '1.5.0.rc1'
+::RUBY_RELEASE_DATE   = '2022-04-06'
 ::RUBY_PATCHLEVEL     = 0
 ::RUBY_REVISION       = '0'
-::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'
+::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2022 Adam Beynon and the Opal contributors'
 ::RUBY_DESCRIPTION    = "opal #{::RUBY_ENGINE_VERSION} (#{::RUBY_RELEASE_DATE} revision #{::RUBY_REVISION})"

data/opal/corelib/hash.rb

@@ -423,7 +423,7 @@ class ::Hash
     return enum_for(:each) { size } unless block
 
     %x{
-      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+      for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
@@ -444,7 +444,7 @@ class ::Hash
     return enum_for(:each_key) { size } unless block
 
     %x{
-      for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
+      for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key; i < length; i++) {
         key = keys[i];
 
         block(key.$$is_string ? key : key.key);