opal 0.10.6 → 0.11.0.rc1

data/lib/opal/nodes/csend.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'opal/nodes/call'
+
+module Opal
+  module Nodes
+
+    # Safe navigator recv&.meth(arglist, &block)
+    class CSendNode < CallNode
+      handle :csend
+
+      def default_compile
+        helper :send
+
+        conditional_send(recv(receiver_sexp)) do |receiver_temp|
+          push "$send(", receiver_temp
+          compile_method_name
+          compile_arguments
+          compile_block_pass
+          push ')'
+        end
+      end
+    end
+
+  end
+end

data/lib/opal/nodes/def.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/node_with_args'
 
 module Opal
@@ -6,13 +7,19 @@ module Opal
     class DefNode < NodeWithArgs
       handle :def
 
-      children :recvr, :mid, :args, :stmts
+      children :mid, :args, :stmts
 
       attr_accessor :block_arg
 
       def extract_block_arg
-        if args.last.is_a?(Sexp) && args.last.type == :blockarg
-          @block_arg = args.pop[1]
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            mid,
+            s(:args, *regular_args),
+            stmts
+          ])
         end
       end
 
@@ -25,12 +32,12 @@ module Opal
 
         # block name (&block)
         if block_arg
-          block_name = variable(block_arg).to_sym
+          block_name = block_arg
         end
 
         in_scope do
           scope.mid = mid
-          scope.defs = true if recvr
+          scope.defs = true if @sexp.type == :defs
 
           if block_name
             scope.uses_block!
@@ -40,6 +47,7 @@ module Opal
           scope.block_name = block_name || '$yield'
 
           inline_params = process(inline_args_sexp)
+
           stmt_code = stmt(compiler.returns(stmts))
 
           add_temp 'self = this'
@@ -58,13 +66,12 @@ module Opal
 
           if scope.uses_zuper
             add_local '$zuper'
-            add_local '$zuper_index'
-            add_local '$zuper_length'
+            add_local '$zuper_i'
+            add_local '$zuper_ii'
 
-            line "$zuper = [];"
-            line
-            line "for($zuper_index = 0; $zuper_index < arguments.length; $zuper_index++) {"
-            line "  $zuper[$zuper_index] = arguments[$zuper_index];"
+            line "// Prepare super implicit arguments"
+            line "for($zuper_i = 0, $zuper_ii = arguments.length, $zuper = new Array($zuper_ii); $zuper_i < $zuper_ii; $zuper_i++) {"
+            line "  $zuper[$zuper_i] = arguments[$zuper_i];"
             line "}"
           end
 
@@ -86,7 +93,7 @@ module Opal
         # utf8_question = 'ʔ̣'
         # utf8_exclamation 'ǃ'
         #
-        # For now we're just using $, to maintain compatibility with older IEs.
+        # For now we're just using $$, to maintain compatibility with older IEs.
         function_name = valid_name?(mid) ? " $$#{mid}" : ''
 
         unshift ") {"
@@ -101,19 +108,34 @@ module Opal
           push ", #{scope_name}.$$parameters = #{parameters_code}"
         end
 
-        if    recvr                         then unshift 'Opal.defs(', recv(recvr), ", '$#{mid}', "
-        elsif scope.iter?                   then unshift "Opal.def(self, '$#{mid}', "
+        if compiler.parse_comments?
+          push ", #{scope_name}.$$comments = #{comments_code}"
+        end
+
+        if compiler.enable_source_location?
+          push ", #{scope_name}.$$source_location = #{source_location}"
+        end
+
+        wrap_with_definition
+      end
+
+      def wrap_with_definition
+        if    scope.iter?                   then unshift "Opal.def(self, '$#{mid}', "
         elsif scope.module? || scope.class? then unshift "Opal.defn(self, '$#{mid}', "
-        elsif scope.sclass? && scope.defs   then unshift "Opal.defs(self, '$#{mid}', "
         elsif scope.sclass?                 then unshift "Opal.defn(self, '$#{mid}', "
         elsif compiler.eval?                then unshift "Opal.def(self, '$#{mid}', "
         elsif scope.top?                    then unshift "Opal.defn(Opal.Object, '$#{mid}', "
         elsif scope.def?                    then unshift "Opal.def(self, '$#{mid}', "
         else raise "Unsupported use of `def`; please file a bug at https://github.com/opal/opal/issues/new reporting this message."
         end
+
         push ')'
 
-        wrap '(', ", nil) && '#{mid}'" if expr?
+        if expr?
+          wrap '(', ", nil) && '#{mid}'"
+        else
+          unshift "\n#{current_indent}"
+        end
       end
 
       # Returns code used in debug mode to check arity of method call
@@ -124,6 +146,17 @@ module Opal
           push " if (#{arity_checks.join(' || ')}) { Opal.ac($arity, #{arity}, this, #{meth}); }"
         end
       end
+
+      def source_location
+        file = @sexp.loc.expression.source_buffer.name
+        line = @sexp.loc.line
+
+        "['#{file}.rb', #{line}]"
+      end
+
+      def comments_code
+        '[' + comments.map { |comment| comment.text.inspect }.join(', ') + ']'
+      end
     end
   end
 end

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,65 @@ 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, :until, :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.each_with_index do |child, idx|
+          push ', ' unless idx == 0
+          push process(child, level)
         end
       end
     end
+
+    class KwBeginNode < BeginNode
+      handle :kwbegin
+    end
   end
 end