opal 0.11.4 → 1.0.0.beta1

data/lib/opal/nodes/args/extract_kwrestarg.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for extracting a single
+      # splat keyword argument from $kwargs
+      #
+      # $kwargs always exist (as argument when inlining is possible
+      # and as a local variable when it's not)
+      #
+      class ExtractKwrestarg < Base
+        handle :extract_kwrestarg
+        children :name
+
+        def compile
+          if name
+            add_temp name
+            line "#{name} = Opal.kwrestargs($kwargs, #{used_kwargs});"
+          end
+        end
+
+        def used_kwargs
+          args = scope.used_kwargs.map do |arg_name|
+            "'#{arg_name}': true"
+          end
+
+          "{#{args.join ','}}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/extract_optarg.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # Compiles extraction of a single inline optional argument
+      # def m(a = 1); end
+      #       ^^^^^
+      #
+      # This node doesn't exist in the original AST,
+      # InlineArgs rewriter creates it to simplify compilation
+      #
+      # Sometimes the argument can't be inlined.
+      # In such cases InlineArgs rewriter replaces
+      #   s(:optarg, :arg_name, ...default value...)
+      # to:
+      #   s(:fakearg) + s(:extract_post_optarg, :arg_name, ...default value...)
+      #
+      class ExtractOptargNode < Base
+        handle :extract_optarg
+        children :name, :default_value
+
+        def compile
+          return if default_value.children[1] == :undefined
+
+          line "if (#{name} == null) {"
+          line "  #{name} = ", expr(default_value), ";"
+          line "}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/extract_post_arg.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for extracting a single
+      # required post-argument from $post_args
+      #
+      class ExtractPostArg < Base
+        handle :extract_post_arg
+        children :name
+
+        def compile
+          add_temp name
+
+          line "#{name} = $post_args[0];"
+          line "$post_args.splice(0, 1);"
+
+          line "if (#{name} == null) {"
+          line "  #{name} = nil"
+          line "}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/extract_post_optarg.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for extracting a single
+      # optional post-argument
+      #
+      # args_to_keep is the number of required post-arguments
+      #
+      #   def m(a = 1, b, c, d); end
+      # becomes something like:
+      #   if post_args.length > 3
+      #     a = post_args[0]
+      #     post_args = post_args[1..-1]
+      #   end
+      #
+      class ExtractPostOptarg < Base
+        handle :extract_post_optarg
+        children :name, :default_value, :args_to_keep
+
+        def compile
+          add_temp name
+
+          line "if ($post_args.length > #{args_to_keep}) {"
+          line "  #{name} = $post_args[0];"
+          line "  $post_args.splice(0, 1);"
+          line "}"
+
+          return if default_value.children[1] == :undefined
+
+          line "if (#{name} == null) {"
+          line "  #{name} = ", expr(default_value), ";"
+          line "}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/extract_restarg.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for extracting a splat argument from post-arguments
+      #
+      # args_to_keep is the number of required post-arguments
+      #
+      #   def m(*a, b, c, d); end
+      # becomes something like:
+      #   a = post_args[0..-3]
+      #   post_args = post_args[-3..-1]
+      #
+      class ExtractRestarg < Base
+        handle :extract_restarg
+        children :name, :args_to_keep
+
+        def compile
+          if name
+            add_temp name
+
+            if args_to_keep == 0
+              # no post-args, we are free to grab everything
+              line "#{name} = $post_args;"
+            else
+              line "#{name} = $post_args.splice(0, $post_args.length - #{args_to_keep});"
+            end
+          elsif args_to_keep != 0
+            # def m(*, a)
+            # We still have to "cut" our splat
+            line "$post_args.splice(0, $post_args.length - #{args_to_keep});"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/fake_arg.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # Compiles a fake argument produced by the InlineArgs rewriter.
+      #
+      # This argument represents an argument from the
+      # Ruby code that gets initialized later in the function body.
+      #
+      # def m(a = 1, b); end
+      #              ^
+      class FakeArgNode < Base
+        handle :fake_arg
+
+        def compile
+          name = scope.next_temp
+          scope.add_arg name
+          push name
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/initialize_iterarg.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for initializing a single
+      # required block arg
+      #
+      #   proc { |a| }
+      #
+      # Procs don't have arity checking and code like
+      #   proc { |a| }.call
+      # must return nil
+      class InitializeIterarg < Base
+        handle :initialize_iter_arg
+        children :name
+
+        def compile
+          line "if (#{name} == null) {"
+          line "  #{name} = nil;"
+          line "}"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/initialize_shadowarg.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # This node is responsible for initializing a shadow arg
+      #
+      # proc { |;a| }
+      #
+      class InitializeShadowarg < Base
+        handle :initialize_shadowarg
+        children :name
+
+        def compile
+          scope.locals << name
+          scope.add_arg(name)
+          line "#{name} = nil;"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/parameters.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Opal
+  module Nodes
+    module Args
+      class Parameters
+        def initialize(args)
+          @args = args.children
+        end
+
+        def to_code
+          stringified_parameters = @args.map do |arg|
+            public_send(:"on_#{arg.type}", *arg)
+          end
+
+          "[#{stringified_parameters.compact.join(', ')}]"
+        end
+
+        def on_arg(arg_name)
+          %{['req', '#{arg_name}']}
+        end
+
+        def on_mlhs(*)
+          %{['req']}
+        end
+
+        def on_optarg(arg_name, _default_value)
+          %{['opt', '#{arg_name}']}
+        end
+
+        def on_restarg(arg_name = nil)
+          if arg_name
+            %{['rest', '#{arg_name}']}
+          else
+            %{['rest']}
+          end
+        end
+
+        def on_kwarg(arg_name)
+          %{['keyreq', '#{arg_name}']}
+        end
+
+        def on_kwoptarg(arg_name, _default_value)
+          %{['key', '#{arg_name}']}
+        end
+
+        def on_kwrestarg(arg_name = nil)
+          if arg_name
+            %{['keyrest', '#{arg_name}']}
+          else
+            %{['keyrest']}
+          end
+        end
+
+        def on_blockarg(arg_name)
+          %{['block', '#{arg_name}']}
+        end
+
+        def on_shadowarg(_arg_name); end
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/prepare_post_args.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    module Args
+      # A utility node responsible for preparing
+      # post-argument for :extract_post_* nodes
+      class PreparePostArgs < Base
+        handle :prepare_post_args
+        children :offset
+
+        def compile
+          add_temp '$post_args'
+
+          line "$post_args = Opal.slice.call(arguments, #{offset}, arguments.length)"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/array.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/nodes/base'
 
 module Opal
@@ -18,33 +19,33 @@ module Opal
           if splat
             if work.empty?
               if code.empty?
-                code << fragment("[].concat(") << part << fragment(")")
+                code << fragment('[].concat(') << part << fragment(')')
               else
-                code << fragment(".concat(") << part << fragment(")")
+                code << fragment('.concat(') << part << fragment(')')
               end
             else
               if code.empty?
-                code << fragment("[") << work << fragment("]")
+                code << fragment('[') << work << fragment(']')
               else
-                code << fragment(".concat([") << work << fragment("])")
+                code << fragment('.concat([') << work << fragment('])')
               end
 
-              code << fragment(".concat(") << part << fragment(")")
+              code << fragment('.concat(') << part << fragment(')')
             end
             work = []
           else
-            work << fragment(", ") unless work.empty?
+            work << fragment(', ') unless work.empty?
             work << part
           end
         end
 
         unless work.empty?
-          join = [fragment("["), work, fragment("]")]
+          join = [fragment('['), work, fragment(']')]
 
           if code.empty?
             code = join
           else
-            code.push([fragment(".concat("), join, fragment(")")])
+            code.push([fragment('.concat('), join, fragment(')')])
           end
         end
 

data/lib/opal/nodes/base.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/nodes/helpers'
 
 module Opal
@@ -45,12 +46,12 @@ module Opal
         return @fragments if defined?(@fragments)
 
         @fragments = []
-        self.compile
+        compile
         @fragments
       end
 
       def compile
-        raise "Not Implemented"
+        raise 'Not Implemented'
       end
 
       def push(*strs)
@@ -117,7 +118,7 @@ module Opal
       end
 
       def expr_or_nil(sexp)
-        sexp ? expr(sexp) : "nil"
+        sexp ? expr(sexp) : 'nil'
       end
 
       def add_local(name)
@@ -164,19 +165,27 @@ module Opal
         scope.in_ensure?
       end
 
-      def closest_module_node
-        current = scope
-        while current && !current.class_scope?
-          current = current.parent
+      def class_variable_owner_nesting_level
+        cvar_scope = scope
+        nesting_level = 0
+
+        while cvar_scope && !cvar_scope.class_scope?
+          # Needs only `class << self`, `module`, and `class`
+          # can increase nesting, but `class` & `module` are
+          # covered by `class_scope?`.
+          nesting_level += 1 if cvar_scope.sclass?
+
+          cvar_scope = cvar_scope.parent
         end
-        current
+
+        nesting_level
       end
 
       def class_variable_owner
-        if closest_module_node
-          "$#{closest_module_node.name}"
+        if scope
+          "$nesting[#{class_variable_owner_nesting_level}]"
         else
-          "Opal.Object"
+          'Opal.Object'
         end
       end