opal 1.4.1 → 1.5.0.rc1

data/lib/opal/nodes/if.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'opal/nodes/base'
+require 'opal/ast/matcher'
 
 module Opal
   module Nodes
@@ -18,6 +19,8 @@ module Opal
           else
             compile_with_ternary
           end
+        elsif could_become_switch?
+          compile_with_switch
         else
           compile_with_if
         end
@@ -158,6 +161,225 @@ module Opal
           true
         end
       end
+
+      # NOTE: all following matcher will act on case/when statements in their rewitten form:
+      #
+      #   bin/opal --sexp -e'case some_value_or_expression; when 123; when 456, 789; end'
+      #
+      #   s(:top,
+      #     s(:if,
+      #       s(:send,
+      #         s(:int, 123), :===,
+      #         s(:lvasgn, "$ret_or_1",
+      #           s(:send, nil, :some_value_or_expression))), nil,
+      #       s(:if,
+      #         s(:if,
+      #           s(:send,
+      #             s(:int, 456), :===,
+      #             s(:js_tmp, "$ret_or_1")),
+      #           s(:true),
+      #           s(:send,
+      #             s(:int, 789), :===,
+      #             s(:js_tmp, "$ret_or_1"))), nil,
+      #         s(:nil))))
+      #
+
+      # Matches: `case some_value_or_expression; when 123`
+      # Captures: [s(:int, 123), "$ret_or_1", s(:send, nil, :some_value_or_expression))]
+      SWITCH_TEST_MATCH = AST::Matcher.new do
+        s(:send,
+          cap(s(%i[float int sym str true false nil], :*)),
+          :===,
+          s(:lvasgn, cap(:*), cap(:*))
+        )
+      end
+
+      # Matches: case some_value_or_expression; when 123, 456; end
+      # Captures: [
+      #   s(:int, 123),
+      #   "$ret_or_1",
+      #   s(:send, nil, :some_value_or_expression)),
+      #   …here we delegate to either SWITCH_BRANCH_TEST_MATCH or SWITCH_BRANCH_TEST_MATCH_CONTINUED
+      # ]
+      SWITCH_TEST_MATCH_CONTINUED = AST::Matcher.new do
+        s(:if,
+          s(:send,
+            cap(s(%i[float int sym str true false nil], :*)),
+            :===,
+            s(:lvasgn, cap(:*), cap(:*))
+          ),
+          s(:true),
+          cap(:*)
+        )
+      end
+
+      # Matches: `when 456` (from `case foo; when 123; when 456; end`)
+      # Captures: [s(:int, 456), "$ret_or_1"]
+      SWITCH_BRANCH_TEST_MATCH = AST::Matcher.new do
+        s(:send,
+          cap(s(%i[float int sym str true false nil], :*)),
+          :===,
+          s(:js_tmp, cap(:*))
+        )
+      end
+
+      # Matches: `when 456`
+      # Captures: [
+      #   s(:int, 789),
+      #   "$ret_or_1",
+      #   …here we delegate to either SWITCH_BRANCH_TEST_MATCH or SWITCH_BRANCH_TEST_MATCH_CONTINUED
+      # ]
+      SWITCH_BRANCH_TEST_MATCH_CONTINUED = AST::Matcher.new do
+        s(:if,
+          s(:send,
+            cap(s(%i[float int sym str true false nil], :*)),
+            :===,
+            s(:js_tmp, cap(:*))
+          ),
+          s(:true),
+          cap(:*)
+        )
+      end
+
+      def could_become_switch?
+        return false if expects_expression?
+
+        return true if sexp.meta[:switch_child]
+
+        test_match = SWITCH_TEST_MATCH.match(test) || SWITCH_TEST_MATCH_CONTINUED.match(test)
+        return false unless test_match
+        @switch_test, @switch_variable, @switch_first_test, additional_rules = *test_match
+
+        additional_rules = handle_additional_switch_rules(additional_rules)
+        return false unless additional_rules # It's ok for them to be empty, but false denotes a mismatch
+        @switch_additional_rules = additional_rules
+
+        return false unless valid_switch_body?(true_body)
+
+        could_become_switch_branch?(false_body)
+      end
+
+      def handle_additional_switch_rules(additional_rules)
+        switch_additional_rules = []
+        while additional_rules
+          match = SWITCH_BRANCH_TEST_MATCH.match(additional_rules) || SWITCH_BRANCH_TEST_MATCH_CONTINUED.match(additional_rules)
+          return false unless match
+
+          switch_test, switch_variable, additional_rules = *match
+          return false unless switch_variable == @switch_variable
+
+          switch_additional_rules << switch_test
+        end
+        switch_additional_rules
+      end
+
+      def could_become_switch_branch?(body)
+        if !body
+          return true
+        elsif body.type != :if
+          if valid_switch_body?(body)
+            body.meta[:switch_default] = true
+            return true
+          end
+          return false
+        end
+
+        test, true_body, false_body = *body
+
+        test_match = SWITCH_BRANCH_TEST_MATCH.match(test) || SWITCH_BRANCH_TEST_MATCH_CONTINUED.match(test)
+        unless test_match
+          if valid_switch_body?(body, true)
+            body.meta[:switch_default] = true
+            return true
+          end
+        end
+        switch_test, switch_variable, additional_rules = *test_match
+
+        switch_additional_rules = handle_additional_switch_rules(additional_rules)
+        return false unless switch_additional_rules # It's ok for them to be empty, but false denotes a mismatch
+
+        return false unless switch_variable == @switch_variable
+
+        return false unless valid_switch_body?(true_body)
+        return false unless could_become_switch_branch?(false_body)
+
+        body.meta.merge!(switch_child: true,
+                         switch_test: switch_test,
+                         switch_variable: @switch_variable,
+                         switch_additional_rules: switch_additional_rules
+        )
+
+        true
+      end
+
+      def valid_switch_body?(body, check_variable = false)
+        case body
+        when AST::Node
+          case body.type
+          when :break, :redo, :retry
+            false
+          when :iter, :while
+            # Don't traverse the iters or whiles!
+            true
+          else
+            body.children.all? { |i| valid_switch_body?(i, check_variable) }
+          end
+        when @switch_variable
+          # Perhaps we ended abruptly and we lack a $ret_or variable... but sometimes
+          # we can ignore this.
+          !check_variable
+        else
+          true
+        end
+      end
+
+      def compile_with_switch
+        if sexp.meta[:switch_child]
+          @switch_variable = sexp.meta[:switch_variable]
+          @switch_additional_rules = sexp.meta[:switch_additional_rules]
+          compile_switch_case(sexp.meta[:switch_test])
+        else
+          line "switch (", expr(@switch_first_test), ") {"
+          indent do
+            compile_switch_case(@switch_test)
+          end
+          line "}"
+        end
+      end
+
+      def returning?(body)
+        %i[return js_return next].include?(body.type) ||
+          (body.type == :begin && %i[return js_return next].include?(body.children.last.type))
+      end
+
+      def compile_switch_case(test)
+        line "case ", expr(test), ":"
+        if @switch_additional_rules
+          @switch_additional_rules.each do |rule|
+            line "case ", expr(rule), ":"
+          end
+        end
+        indent do
+          line stmt(true_body)
+          line "break;" if !true_body || !returning?(true_body)
+        end
+        if false_body
+          if false_body.meta[:switch_default]
+            compile_switch_default
+          elsif false_body.meta[:switch_child]
+            push stmt(false_body)
+          end
+        else
+          push stmt(s(:nil))
+        end
+      end
+
+      def compile_switch_default
+        line "default:"
+        indent do
+          line stmt(false_body)
+        end
+      end
     end
 
     class IFlipFlop < Base

data/lib/opal/nodes/iter.rb

@@ -8,45 +8,12 @@ module Opal
     class IterNode < NodeWithArgs
       handle :iter
 
-      children :inline_args, :body
+      children :inline_args, :stmts
 
       def compile
         is_lambda! if scope.lambda_definition?
 
-        inline_params = nil
-
-        to_vars = identity = body_code = nil
-
-        in_scope do
-          identity = scope.identify!
-
-          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
-
-          if scope.catch_return
-            unshift "try {\n"
-            line '} catch ($returner) { if ($returner === Opal.returner) { return $returner.$v }'
-            push ' throw $returner; }'
-          end
-        end
-
-        unshift to_vars
-
-        if await_encountered
-          unshift "async function #{identity}(", inline_params, '){'
-        else
-          unshift "function #{identity}(", inline_params, '){'
-        end
-        push '}'
+        compile_body_or_shortcut
 
         blockopts = []
         blockopts << "$$arity: #{arity}"
@@ -83,6 +50,43 @@ module Opal
         scope.relative_access if @define_relative_access
       end
 
+      def compile_body
+        inline_params = nil
+
+        to_vars = identity = body_code = nil
+
+        in_scope do
+          identity = scope.identify!
+
+          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
+
+          if scope.catch_return
+            unshift "try {\n"
+            line '} catch ($returner) { if ($returner === Opal.returner) { return $returner.$v }'
+            push ' throw $returner; }'
+          end
+        end
+
+        unshift to_vars
+
+        if await_encountered
+          unshift "async function #{identity}(", inline_params, '){'
+        else
+          unshift "function #{identity}(", inline_params, '){'
+        end
+        push '}'
+      end
+
       def compile_block_arg
         if block_arg
           scope.prepare_block
@@ -108,13 +112,13 @@ module Opal
         @sexp = @sexp.updated(
           nil, [
             args.updated(nil, valid_args),
-            body
+            stmts
           ]
         )
       end
 
       def returned_body
-        compiler.returns(body || s(:nil))
+        compiler.returns(stmts || s(:nil))
       end
 
       def has_top_level_mlhs_arg?

data/lib/opal/nodes/literal.rb

@@ -326,7 +326,7 @@ module Opal
       children :value
 
       def compile
-        push "Opal.Rational.$new(#{value.numerator}, #{value.denominator})"
+        push "#{top_scope.absolute_const}('Rational').$new(#{value.numerator}, #{value.denominator})"
       end
     end
 
@@ -338,7 +338,7 @@ module Opal
       children :value
 
       def compile
-        push "Opal.Complex.$new(#{value.real}, #{value.imag})"
+        push "#{top_scope.absolute_const}('Complex').$new(#{value.real}, #{value.imag})"
       end
     end
   end

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/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.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