opal 0.11.4 → 1.0.0.beta1

data/lib/opal/rewriters/dot_js_syntax.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 
 module Opal
@@ -12,14 +13,14 @@ module Opal
             case meth
             when :[]
               if args.size != 1
-                raise SyntaxError, ".JS[:property] syntax supports only one argument"
+                error '.JS[:property] syntax supports only one argument'
               end
               property = args.first
 
               node = to_js_attr_call(recv_of_recv, property)
             when :[]=
               if args.size != 2
-                raise SyntaxError, '.JS[:property]= syntax supports only two arguments'
+                error '.JS[:property]= syntax supports only two arguments'
               end
 
               property, value = *args

data/lib/opal/rewriters/dump_args.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class DumpArgs < Base
+      def on_def(node)
+        node = super(node)
+        _mid, args, _body = *node
+        node.updated(nil, nil, meta: { original_args: args })
+      end
+
+      def on_defs(node)
+        node = super(node)
+        _recv, _mid, args, _body = *node
+
+        node.updated(nil, nil, meta: { original_args: args })
+      end
+
+      def on_iter(node)
+        node = super(node)
+        args, _body = *node
+        node.updated(nil, nil, meta: { original_args: args })
+      end
+    end
+  end
+end

data/lib/opal/rewriters/explicit_writer_return.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 
 module Opal
@@ -12,7 +13,7 @@ module Opal
       GET_ARGS_NODE = s(:lvar, TMP_NAME)
       RETURN_ARGS_NODE = s(:jsattr,
         GET_ARGS_NODE,
-        s(:send, s(:jsattr, GET_ARGS_NODE, s(:str, 'length')), :-, s(:int, 1))
+        s(:send, s(:jsattr, GET_ARGS_NODE, s(:str, 'length')), :-, s(:int, 1)),
       )
 
       def on_send(node)
@@ -20,13 +21,13 @@ module Opal
 
         recv, method_name, *args = *node
 
-        if method_name.to_s =~ /#{REGEXP_START}\w+=#{REGEXP_END}/ || method_name.to_s == "[]="
+        if method_name.to_s =~ /#{REGEXP_START}\w+=#{REGEXP_END}/ || method_name.to_s == '[]='
           set_args_node = s(:lvasgn, TMP_NAME, s(:array, *process_all(args)))
 
           s(:begin,
             set_args_node,
             node.updated(nil, [recv, method_name, s(:splat, GET_ARGS_NODE)]),
-            RETURN_ARGS_NODE
+            RETURN_ARGS_NODE,
           )
         else
           super

data/lib/opal/rewriters/for_rewriter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 
 module Opal
@@ -49,26 +50,25 @@ module Opal
         get_tmp_loop_variable = s(:js_tmp, tmp_loop_variable)
 
         loop_variable_assignment = case loop_variable.type
-        when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
-          # i, j = __jstmp
-          s(:masgn, loop_variable, get_tmp_loop_variable)
-        else # single argument like "for i in (0..3)"
-          # i = __jstmp
-          loop_variable << get_tmp_loop_variable
-        end
+                                   when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
+                                     # i, j = __jstmp
+                                     s(:masgn, loop_variable, get_tmp_loop_variable)
+                                   else # single argument like "for i in (0..3)"
+                                     # i = __jstmp
+                                     loop_variable << get_tmp_loop_variable
+                                   end
 
         loop_body = prepend_to_body(loop_body, loop_variable_assignment)
 
         node = s(:send, iterating_value, :each,          # (0..3).each {
           s(:iter, s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
-          loop_body)                                     #                          i = __jstmp; j = i + 1 }
-        )
+            loop_body
+          )
+        )                                                #                          i = __jstmp; j = i + 1 }
 
         s(:begin, *outer_assigns, node)
       end
 
-      private
-
       class LocalVariableAssigns < Base
         attr_reader :result
 
@@ -84,7 +84,7 @@ module Opal
 
         def on_lvasgn(node)
           name, _ = *node
-          self.result << name
+          result << name
           super
         end
       end

data/lib/opal/rewriters/hashes/key_duplicates_rewriter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 require 'set'
 
@@ -20,7 +21,7 @@ module Opal
         def on_pair(node)
           key, _value = *node
 
-          if %i(str sym).include?(key.type)
+          if %i[str sym].include?(key.type)
             @keys << key
           end
 

data/lib/opal/rewriters/inline_args.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+require 'opal/rewriters/arguments'
+
+module Opal
+  module Rewriters
+    # Converts
+    #
+    #   def m( a, b = 1, *c, d, e:, f: 1, **g, &blk )
+    #   end
+    #
+    # To something like
+    #
+    #   def m( a, <fake b>, <fake c>, <fake d>, <fake kwargs>)
+    #     blk = <extract block>
+    #     $post_args = arguments[1..-1]
+    #     $kwargs = $post_args.pop
+    #     a = <enough args> ? $post_args.shift : 1
+    #     c = <enough args> ? $post_args[0..-1] : []
+    #     d = $post_args.last
+    #     e = $kwargs.delete(:e)
+    #     f = $kwargs.delete(:f) || 1
+    #     g = $kwargs.except(:e, :f)
+    #   end
+    #
+    class InlineArgs < Base
+      def on_def(node)
+        node = super(node)
+        mid, args, body = *node
+
+        body ||= s(:nil) # prevent returning initialization statement
+
+        initializer = Initializer.new(args, type: :def)
+        inline_args = args.updated(nil, initializer.inline)
+        body = prepend_to_body(body, initializer.initialization)
+
+        node.updated(nil, [mid, inline_args, body])
+      end
+
+      def on_defs(node)
+        node = super(node)
+        recv, mid, args, body = *node
+
+        body ||= s(:nil) # prevent returning initialization statement
+
+        initializer = Initializer.new(args, type: :defs)
+        inline_args = args.updated(nil, initializer.inline)
+        body = prepend_to_body(body, initializer.initialization)
+
+        node.updated(nil, [recv, mid, inline_args, body])
+      end
+
+      def on_iter(node)
+        node = super(node)
+        args, body = *node
+
+        body ||= s(:nil) # prevent returning initialization statement
+
+        initializer = Initializer.new(args, type: :iter)
+        inline_args = args.updated(nil, initializer.inline)
+        body = prepend_to_body(body, initializer.initialization)
+
+        node.updated(nil, [inline_args, body])
+      end
+
+      class Initializer < ::Opal::Rewriters::Base
+        attr_reader :inline, :initialization
+
+        STEPS = %i[
+          extract_blockarg
+          initialize_shadowargs
+          extract_args
+
+          prepare_post_args
+          prepare_kwargs
+
+          extract_optargs
+          extract_restarg
+          extract_post_args
+
+          extract_kwargs
+          extract_kwoptargs
+          extract_kwrestarg
+        ].freeze
+
+        def initialize(args, type:)
+          @args = Arguments.new(args.children)
+
+          @inline = []
+          @initialization = []
+
+          @type = type
+          @underscore_found = false
+
+          STEPS.each do |step|
+            send(step)
+          end
+
+          if @initialization.any?
+            @initialization = s(:begin, *@initialization)
+          else
+            @initialization = nil
+          end
+        end
+
+        def extract_blockarg
+          if (arg = @args.blockarg)
+            @initialization << arg.updated(:extract_blockarg)
+          end
+        end
+
+        def initialize_shadowargs
+          @args.shadowargs.each do |arg|
+            @initialization << arg.updated(:initialize_shadowarg)
+          end
+        end
+
+        def extract_args
+          @args.args.each do |arg|
+            if @type == :iter
+              # block args are not required,
+              # so we neeed to tell compiler that required args
+              # must be initialized with nil-s
+              @initialization << arg.updated(:initialize_iter_arg)
+
+              if arg.children[0] == :_
+                if @underscore_found
+                  # for proc { |_, _| _ }.call(1, 2) result must be 1
+                  # here we convert all underscore args starting from the 2nd
+                  # to a "fake" arg
+                  arg = s(:fake_arg)
+                end
+
+                @underscore_found = true
+              end
+            else
+              # required inline def argument like 'def m(req)'
+              # no initialization is required
+            end
+            @inline << arg
+          end
+        end
+
+        def prepare_post_args
+          if @args.has_post_args?
+            @initialization << s(:prepare_post_args, @args.args.length)
+          end
+        end
+
+        def prepare_kwargs
+          return unless @args.has_any_kwargs?
+
+          if @args.can_inline_kwargs?
+            @inline << s(:arg, :'$kwargs')
+          else
+            @initialization << s(:extract_kwargs)
+            @inline << s(:fake_arg)
+          end
+
+          @initialization << s(:ensure_kwargs_are_kwargs)
+        end
+
+        def extract_kwargs
+          @args.kwargs.each do |arg|
+            @initialization << arg.updated(:extract_kwarg)
+          end
+        end
+
+        def extract_kwoptargs
+          @args.kwoptargs.each do |arg|
+            @initialization << arg.updated(:extract_kwoptarg)
+          end
+        end
+
+        def extract_kwrestarg
+          if (arg = @args.kwrestarg)
+            @initialization << arg.updated(:extract_kwrestarg)
+          end
+        end
+
+        def extract_post_args
+          # post arguments must be extracted with an offset
+          @args.postargs.each do |arg|
+            @initialization << arg.updated(:extract_post_arg)
+            @inline << s(:fake_arg)
+          end
+        end
+
+        def extract_optargs
+          has_post_args = @args.has_post_args?
+          @args.optargs.each do |arg|
+            if has_post_args
+              # optional post argument like 'def m(opt = 1, a)'
+              arg_name, default_value = *arg
+              @initialization << arg.updated(:extract_post_optarg, [arg_name, default_value, args_to_keep])
+              @inline << s(:fake_arg)
+            else
+              # optional inline argument like 'def m(a, opt = 1)'
+              @inline << arg.updated(:arg)
+              @initialization << arg.updated(:extract_optarg)
+            end
+          end
+        end
+
+        def extract_restarg
+          if (arg = @args.restarg)
+            arg_name = arg.children[0]
+            @initialization << arg.updated(:extract_restarg, [arg_name, args_to_keep])
+            @inline << s(:fake_arg)
+          end
+        end
+
+        def args_to_keep
+          @args.postargs.length
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/js_reserved_words.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 require 'opal/regexp_anchors'
 
@@ -28,15 +29,15 @@ module Opal
       RESERVED_FUNCTION_NAMES = /#{REGEXP_START}(?:Array)#{REGEXP_END}/
 
       def self.valid_name?(name)
-        BASIC_IDENTIFIER_RULES =~ name and not(
-          ES51_RESERVED_WORD          =~ name or
-          ES3_RESERVED_WORD_EXCLUSIVE =~ name or
-          IMMUTABLE_PROPS             =~ name
+        BASIC_IDENTIFIER_RULES =~ name && !(
+          ES51_RESERVED_WORD =~ name ||
+          ES3_RESERVED_WORD_EXCLUSIVE =~ name ||
+          IMMUTABLE_PROPS =~ name
         )
       end
 
       def self.valid_ivar_name?(name)
-        not (PROTO_SPECIAL_PROPS =~ name or PROTO_SPECIAL_METHODS =~ name)
+        !(PROTO_SPECIAL_PROPS =~ name || PROTO_SPECIAL_METHODS =~ name)
       end
 
       def fix_var_name(name)
@@ -56,11 +57,12 @@ module Opal
       def on_lvasgn(node)
         name, value = *node
 
-        if value
-          node = node.updated(nil, [fix_var_name(name), value])
-        else
-          node = node.updated(nil, [fix_var_name(name)])
-        end
+        node =
+          if value
+            node.updated(nil, [fix_var_name(name), value])
+          else
+            node.updated(nil, [fix_var_name(name)])
+          end
 
         super(node)
       end
@@ -74,11 +76,13 @@ module Opal
       def on_ivasgn(node)
         name, value = *node
 
-        if value
-          node = node.updated(nil, [fix_ivar_name(name), value])
-        else
-          node = node.updated(nil, [fix_ivar_name(name)])
-        end
+        node =
+          if value
+            node.updated(nil, [fix_ivar_name(name), value])
+          else
+            node.updated(nil, [fix_ivar_name(name)])
+          end
+
         super(node)
       end
 
@@ -89,7 +93,7 @@ module Opal
         name, _ = *node
 
         if name
-          node = node.updated(nil, [fix_var_name(name)], meta: {arg_name: name})
+          node = node.updated(nil, [fix_var_name(name)], meta: { arg_name: name })
         end
 
         node
@@ -101,7 +105,7 @@ module Opal
         fixed_name = fix_var_name(name)
         new_children = value ? [fixed_name, value] : [fixed_name]
 
-        node.updated(nil, new_children, meta: {arg_name: name})
+        node.updated(nil, new_children, meta: { arg_name: name })
       end
     end
   end