opal 0.10.0 → 0.11.0

data/lib/opal/nodes/defined.rb

@@ -1,111 +1,221 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
   module Nodes
     class DefinedNode < Base
-      handle :defined
+      handle :defined?
 
       children :value
 
       def compile
-        type = value.type
-
-        case type
+        case value.type
         when :self, :nil, :false, :true
-          push type.to_s.inspect
-        when :lasgn, :iasgn, :gasgn, :cvdecl, :masgn, :op_asgn_or, :op_asgn_and
+          push value.type.to_s.inspect
+        when :lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn, :op_asgn, :or_asgn, :and_asgn
           push "'assignment'"
-        when :paren, :not
-          push expr(s(:defined, value[1]))
         when :lvar
           push "'local-variable'"
-        else
-          if respond_to? "compile_#{type}"
-            __send__ "compile_#{type}"
+        when :begin
+          if value.children.size == 1 && value.children[0].type == :masgn
+            push "'assignment'"
           else
             push "'expression'"
           end
+        when :send
+          compile_defined_send(value)
+          wrap "(", " ? 'method' : nil)"
+        when :ivar
+          compile_defined_ivar(value)
+          wrap "(", " ? 'instance-variable' : nil)"
+        when :zsuper, :super
+          compile_defined_super(value)
+        when :yield
+          compile_defined_yield(value)
+          wrap "(", " ? 'yield' : nil)"
+        when :xstr
+          compile_defined_xstr(value)
+        when :const
+          compile_defined_const(value)
+          wrap "(", " ? 'constant' : nil)"
+        when :cvar
+          compile_defined_cvar(value)
+          wrap "(", " ? 'class variable' : nil)"
+        when :gvar
+          compile_defined_gvar(value)
+          wrap "(", " ? 'global-variable' : nil)"
+        when :back_ref
+          compile_defined_back_ref(value)
+          wrap "(", " ? 'global-variable' : nil)"
+        when :nth_ref
+          compile_defined_nth_ref(value)
+          wrap "(", " ? 'global-variable' : nil)"
+        when :array
+          compile_defined_array(value)
+          wrap "(", " ? 'expression' : nil)"
+        else
+          push "'expression'"
+        end
+      end
+
+      def compile_defined(node)
+        type = node.type
+
+        if respond_to? "compile_defined_#{type}"
+          __send__("compile_defined_#{type}", node)
+        else
+          node_tmp = scope.new_temp
+          push "(#{node_tmp} = ", expr(node), ")"
+          node_tmp
         end
       end
 
-      def compile_call
-        mid = mid_to_jsid value[2].to_s
-        recv = value[1] ? expr(value[1]) : 'self'
+      def wrap_with_try_catch(code)
+        returning_tmp = scope.new_temp
+
+        push "(#{returning_tmp} = (function() { try {"
+        push "  return #{code};"
+        push "} catch ($err) {"
+        push "  if (Opal.rescue($err, [Opal.Exception])) {"
+        push "    try {"
+        push "      return false;"
+        push "    } finally { Opal.pop_exception() }"
+        push "  } else { throw $err; }"
+        push "}})())"
+
+        returning_tmp
+      end
+
+      def compile_send_recv_doesnt_raise(recv_code)
+        wrap_with_try_catch(recv_code)
+      end
+
+      def compile_defined_send(node)
+        recv, method_name, *args = *node
+        mid = mid_to_jsid(method_name.to_s)
+
+        if recv
+          recv_code = compile_defined(recv)
+          push " && "
+
+          if recv.type == :send
+            recv_code = compile_send_recv_doesnt_raise(recv_code)
+            push " && "
+          end
+
+          recv_tmp = scope.new_temp
+          push "(#{recv_tmp} = ", recv_code, ", #{recv_tmp}) && "
+        else
+          recv_tmp = "self"
+        end
+
+        recv_value_tmp = scope.new_temp
+        push "(#{recv_value_tmp} = #{recv_tmp}) && "
+
+        meth_tmp = scope.new_temp
+        push "(((#{meth_tmp} = #{recv_value_tmp}#{mid}) && !#{meth_tmp}.$$stub)"
+
+        push " || #{recv_value_tmp}['$respond_to_missing?']('#{method_name}'))"
 
-        with_temp do |tmp|
-          push "(((#{tmp} = ", recv, "#{mid}) && !#{tmp}.$$stub) || ", recv
-          push "['$respond_to_missing?']('#{value[2].to_s}') ? 'method' : nil)"
+        args.each do |arg|
+          case arg.type
+          when :block_pass
+            # ignoring
+          else
+            push " && "
+            compile_defined(arg)
+          end
         end
+
+        wrap '(', ')'
+        "#{meth_tmp}()"
       end
 
-      def compile_ivar
+      def compile_defined_ivar(node)
+        name = node.children[0].to_s[1..-1]
         # FIXME: this check should be positive for ivars initialized as nil too.
         # Since currently all known ivars are inialized to nil in the constructor
         # we can't tell if it was the user that put nil and made the ivar #defined?
         # or not.
-        with_temp do |tmp|
-          name = value[1].to_s[1..-1]
+        tmp = scope.new_temp
+        push "(#{tmp} = self['#{name}'], #{tmp} != null && #{tmp} !== nil)"
 
-          push "((#{tmp} = self['#{name}'], #{tmp} != null && #{tmp} !== nil) ? "
-          push "'instance-variable' : nil)"
-        end
+        tmp
       end
 
-      def compile_super
-        push expr(s(:defined_super, value))
+      def compile_defined_super(node)
+        push expr s(:defined_super)
       end
 
-      def compile_yield
-        push compiler.handle_block_given_call(@sexp)
-        wrap '((',  ') != null ? "yield" : nil)'
+      def compile_defined_yield(node)
+        scope.uses_block!
+        block_name = scope.block_name || (parent = scope.find_parent_def && parent.block_name)
+        push "(#{block_name} != null && #{block_name} !== nil)"
+        block_name
       end
 
-      def compile_xstr
-        push expr(value)
-        wrap '(typeof(', ') !== "undefined")'
+      def compile_defined_xstr(node)
+        push '(typeof(', expr(node), ') !== "undefined")'
       end
-      alias compile_dxstr compile_xstr
 
-      def compile_const
-        push "($scope.#{value[1]} != null)"
-      end
+      def compile_defined_const(node)
+        const_scope, const_name = *node
 
-      def compile_colon2
-        # TODO: avoid try/catch, probably a #process_colon2 alternative that
-        # does not raise errors is needed
-        push "(function(){ try { return (("
-        push expr(value)
-        push ") != null ? 'constant' : nil); } catch (err) { if (err.$$class"
-        push " === Opal.NameError) { return nil; } else { throw(err); }}; })()"
-      end
+        const_tmp = scope.new_temp
 
-      def compile_colon3
-        push "(Opal.Object.$$scope.#{value[1]} == null ? nil : 'constant')"
+        if const_scope.nil?
+          push "(#{const_tmp} = Opal.const_get_relative($nesting, '#{const_name}', 'skip_raise'))"
+        elsif const_scope == s(:cbase)
+          push "(#{const_tmp} = Opal.const_get_qualified('::', '#{const_name}', 'skip_raise'))"
+        else
+          const_scope_tmp = compile_defined(const_scope)
+          push " && (#{const_tmp} = Opal.const_get_qualified(#{const_scope_tmp}, '#{const_name}', 'skip_raise'))"
+        end
+        const_tmp
       end
 
-      def compile_cvar
-        push "(Opal.cvars['#{value[1]}'] != null ? 'class variable' : nil)"
+
+      def compile_defined_cvar(node)
+        cvar_name, _ = *node
+        cvar_tmp = scope.new_temp
+        push "(#{cvar_tmp} = #{class_variable_owner}.$$cvars['#{cvar_name}'], #{cvar_tmp} != null)"
+        cvar_tmp
       end
 
-      def compile_gvar
-        name = value[1].to_s[1..-1]
+      def compile_defined_gvar(node)
+        helper :gvars
+
+        name = node.children[0].to_s[1..-1]
+        gvar_temp = scope.new_temp
 
         if %w[~ !].include? name
-          push "'global-variable'"
-        elsif %w[` ' + &].include? name
-          with_temp do |tmp|
-            push "((#{tmp} = $gvars['~'], #{tmp} != null && #{tmp} !== nil) ? "
-            push "'global-variable' : nil)"
-          end
+          push "(#{gvar_temp} = ", expr(node), " || true)"
         else
-          push "($gvars[#{name.inspect}] != null ? 'global-variable' : nil)"
+          push "(#{gvar_temp} = $gvars[#{name.inspect}], #{gvar_temp} != null)"
         end
+
+        gvar_temp
+      end
+
+      def compile_defined_back_ref(node)
+        helper :gvars
+        back_ref_temp = scope.new_temp
+        push "(#{back_ref_temp} = $gvars['~'], #{back_ref_temp} != null && #{back_ref_temp} !== nil)"
+        back_ref_temp
+      end
+
+      def compile_defined_nth_ref(node)
+        helper :gvars
+
+        nth_ref_tmp = scope.new_temp
+        push "(#{nth_ref_tmp} = $gvars['~'], #{nth_ref_tmp} != null && #{nth_ref_tmp} != nil)"
+        nth_ref_tmp
       end
 
-      def compile_nth_ref
-        with_temp do |tmp|
-          push "((#{tmp} = $gvars['~'], #{tmp} != null && #{tmp} != nil) ? "
-          push "'global-variable' : nil)"
+      def compile_defined_array(node)
+        node.children.each_with_index do |child, idx|
+          push " && " unless idx == 0
+          compile_defined(child)
         end
       end
     end

data/lib/opal/nodes/definitions.rb

@@ -1,35 +1,16 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
   module Nodes
-
-    class SvalueNode < Base
-      handle :svalue
-
-      children :value
-
-      def compile
-        push process(value, @level)
-      end
-    end
-
     class UndefNode < Base
       handle :undef
 
+      children :value
+
       def compile
         children.each do |child|
-          value = child[1]
-          statements = []
-          if child[0] == :js_return
-             value = value[1]
-             statements << expr(s(:js_return))
-          end
-          statements << "Opal.udef(self, '$#{value.to_s}');"
-          if children.length > 1 && child != children.first
-            line *statements
-          else
-            push *statements
-          end
+          line "Opal.udef(self, '$' + ", expr(child), ");"
         end
       end
     end
@@ -39,139 +20,67 @@ module Opal
 
       children :new_name, :old_name
 
-      def new_mid
-        mid_to_jsid new_name[1].to_s
-      end
-
-      def old_mid
-        mid_to_jsid old_name[1].to_s
-      end
-
       def compile
-        if scope.class? or scope.module?
-          scope.methods << "$#{new_name[1]}"
-        end
-
-        push "Opal.alias(self, '#{new_name[1]}', '#{old_name[1]}')"
+        push "Opal.alias(self, ", expr(new_name), ", ", expr(old_name), ")"
       end
     end
 
-    class BeginNode < Base
+    class BeginNode < ScopeNode
       handle :begin
 
-      children :body
-
       def compile
-        if !stmt? and body.type == :block
-          push stmt(compiler.returns(body))
-          wrap '(function() {', '})()'
-        else
-          push process(body, @level)
-        end
-      end
-    end
-
-    class ParenNode < Base
-      handle :paren
-
-      children :body
-
-      def compile
-        if body.type == :block
-          body.children.each_with_index do |child, idx|
-            push ', ' unless idx == 0
-            push expr(child)
-          end
+        return push "nil" if children.empty?
 
-          wrap '(', ')'
+        if stmt?
+          compile_children(children, @level)
+        elsif simple_children?
+          compile_inline_children(children, @level)
+          wrap '(', ')' if children.size > 1
+        elsif children.size == 1
+          compile_inline_children(returned_children, @level)
         else
-          push process(body, @level)
-          wrap '(', ')' unless stmt?
+          compile_children(returned_children, @level)
+          wrap '(function() {', '})()'
         end
       end
-    end
 
-    class BlockNode < Base
-      handle :block
-
-      def compile
-        return push "nil" if children.empty?
-
-        children.each_with_index do |child, idx|
-          push stmt_join unless idx == 0
-
-          if yasgn = find_inline_yield(child)
-            push compiler.process(yasgn, @level)
-            push ";"
+      def returned_children
+        @returned_children ||= begin
+          *rest, last_child = *children
+          if last_child
+            rest + [compiler.returns(last_child)]
+          else
+            [s(:nil)]
           end
-
-          push compiler.process(child, @level)
-          push ";" if child_is_expr?(child)
         end
       end
 
-      def stmt_join
-        scope.class_scope? ? "\n\n#{current_indent}" : "\n#{current_indent}"
-      end
-
-      def child_is_expr?(child)
-        raw_expression?(child) and [:stmt, :stmt_closure].include?(@level)
+      def compile_children(children, level)
+        children.each do |child|
+          line process(child, level), ";"
+        end
       end
 
-      def raw_expression?(child)
-        ![:xstr, :dxstr].include?(child.type)
-      end
+      COMPLEX_CHILDREN = [:while, :while_post, :until, :until_post, :js_return]
 
-      # When a block sexp gets generated, any inline yields (i.e. yield
-      # statements that are not direct members of the block) need to be
-      # generated as a top level member. This is because if a yield
-      # is returned by a break statement, then the method must return.
-      #
-      # As inline expressions in javascript cannot return, the block
-      # must be rewritten.
-      #
-      # For example, a yield inside an array:
-      #
-      #     [1, 2, 3, yield(4)]
-      #
-      # Must be rewitten into:
-      #
-      #     tmp = yield 4
-      #     [1, 2, 3, tmp]
-      #
-      # This rewriting happens on sexps directly.
-      #
-      # @param [Sexp] stmt sexps to (maybe) rewrite
-      # @return [Sexp]
-      def find_inline_yield(stmt)
-        found = nil
-        case stmt.first
-        when :js_return
-          if found = find_inline_yield(stmt[1])
-            found = found[2]
-          end
-        when :array
-          stmt[1..-1].each_with_index do |el, idx|
-            if el.first == :yield
-              found = el
-              stmt[idx+1] = s(:js_tmp, '$yielded')
-            end
-          end
-        when :call
-          arglist = stmt[3]
-          arglist[1..-1].each_with_index do |el, idx|
-            if el.first == :yield
-              found = el
-              arglist[idx+1] = s(:js_tmp, '$yielded')
-            end
-          end
+      def simple_children?
+        children.none? do |child|
+          COMPLEX_CHILDREN.include?(child.type)
         end
+      end
 
-        if found
-          scope.add_temp '$yielded' unless scope.has_temp? '$yielded'
-          s(:yasgn, '$yielded', found)
+      def compile_inline_children(children, level)
+        children.map do |child|
+          process(child, level)
+        end.reject(&:empty?).each_with_index do |child, idx|
+          push ', ' unless idx == 0
+          push child
         end
       end
     end
+
+    class KwBeginNode < BeginNode
+      handle :kwbegin
+    end
   end
 end

data/lib/opal/nodes/defs.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'opal/nodes/def'
+
+module Opal
+  module Nodes
+    class DefsNode < DefNode
+      handle :defs
+      children :recvr, :mid, :args, :stmts
+
+      def extract_block_arg
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            recvr,
+            mid,
+            s(:args, *regular_args),
+            stmts
+          ])
+        end
+      end
+
+      def wrap_with_definition
+        unshift "Opal.defs(", expr(recvr), ", '$#{mid}', "
+        push ")"
+      end
+    end
+  end
+end

data/lib/opal/nodes/hash.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -12,39 +13,16 @@ module Opal
         @has_kwsplat = false
         @keys = []
         @values = []
-      end
 
-      # Splits keys/values/kwsplats
-      #
-      # hash like { **{ nested: 1 }, d: 2 }
-      # is represetned by sexp:
-      # (:hash,
-      #   (:kwsplat,
-      #     (:hash,
-      #       (:sym, :nested),
-      #       (:int, 1)
-      #     )
-      #   ),
-      #   (:sym, :d),
-      #   (:int, 2),
-      # )
-      # So k/v pairs and kwsplats can be mixed in any order.
-      def extract_kv_pairs_and_kwsplats
-        found_key = false
-
-        children.each do |obj|
-          if obj.type == :kwsplat
-            self.has_kwsplat = true
-          elsif found_key
-            values << obj
-            found_key = false
-          else
-            keys << obj
-            found_key = true
+        children.each do |child|
+          case child.type
+          when :kwsplat
+            @has_kwsplat = true
+          when :pair
+            @keys << child.children[0]
+            @values << child.children[1]
           end
         end
-
-        [keys, values]
       end
 
       def simple_keys?
@@ -52,8 +30,6 @@ module Opal
       end
 
       def compile
-        extract_kv_pairs_and_kwsplats
-
         if has_kwsplat
           compile_merge
         elsif simple_keys?
@@ -103,9 +79,10 @@ module Opal
       def compile_hash
         helper :hash
 
-        children.each_with_index do |child, idx|
+        children.each_with_index do |pair, idx|
+          key, value = pair.children
           push ', ' unless idx == 0
-          push expr(child)
+          push expr(key), ', ', expr(value)
         end
 
         wrap '$hash(', ')'
@@ -118,7 +95,7 @@ module Opal
         helper :hash2
 
         keys.size.times do |idx|
-          key = keys[idx][1].to_s.inspect
+          key = keys[idx].children[0].to_s.inspect
           hash_keys << key unless hash_obj.include? key
           hash_obj[key] = expr(values[idx])
         end