opal 0.10.6 → 0.11.0.rc1

data/lib/opal/nodes/iter.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
 require 'opal/nodes/node_with_args'
+require 'opal/rewriters/break_finder'
 
 module Opal
   module Nodes
     class IterNode < NodeWithArgs
       handle :iter
 
-      children :args_sexp, :body_sexp
+      children :args, :body
 
       attr_accessor :block_arg, :shadow_args
 
@@ -13,6 +15,7 @@ module Opal
         inline_params = nil
         extract_block_arg
         extract_shadow_args
+        extract_underscore_args
         split_args
 
         to_vars = identity = body_code = nil
@@ -33,7 +36,7 @@ module Opal
             compile_arity_check
           end
 
-          body_code = stmt(body)
+          body_code = stmt(returned_body)
           to_vars = scope.to_vars
         end
 
@@ -43,7 +46,7 @@ module Opal
 
         unshift "(#{identity} = function(", inline_params, "){"
         push "}, #{identity}.$$s = self,"
-        push " #{identity}.$$brk = $brk," if compiler.has_break?
+        push " #{identity}.$$brk = $brk," if contains_break?
         push " #{identity}.$$arity = #{arity},"
 
         if compiler.arity_check?
@@ -70,76 +73,89 @@ module Opal
       end
 
       def norm_args
-        @norm_args ||= args[1..-1].select { |arg| arg.type == :arg }
+        @norm_args ||= args.children.select { |arg| arg.type == :arg }
       end
 
       def compile_norm_args
         norm_args.each do |arg|
-          arg = variable(arg[1])
-          push "if (#{arg} == null) #{arg} = nil;"
+          arg_name, _ = *arg
+          push "if (#{arg_name} == null) #{arg_name} = nil;"
         end
       end
 
       def compile_block_arg
         if block_arg
-          block_arg = variable(self.block_arg.to_s)
           scope.block_name = block_arg
           scope.add_temp block_arg
           scope_name = scope.identify!
 
-          line "#{block_arg} = #{scope_name}.$$p || nil, #{scope_name}.$$p = null;"
+          line "#{block_arg} = #{scope_name}.$$p || nil;"
+          line "if (#{block_arg}) #{scope_name}.$$p = null;"
         end
       end
 
       def extract_block_arg
-        if args.is_a?(Sexp) && args.last.is_a?(Sexp) and args.last.type == :block_pass
-          self.block_arg = args.pop[1][1].to_sym
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            s(:args, *regular_args),
+            body
+          ])
         end
       end
 
       def compile_shadow_args
         shadow_args.each do |shadow_arg|
-          scope.add_local(shadow_arg.last)
+          arg_name = shadow_arg.children[0]
+          scope.locals << arg_name
+          scope.add_arg(arg_name)
         end
       end
 
       def extract_shadow_args
-        if args.is_a?(Sexp)
-          @shadow_args = []
-          args.children.each_with_index do |arg, idx|
-            if arg.type == :shadowarg
-              @shadow_args << args.delete(arg)
-            end
+        @shadow_args = []
+        valid_args = []
+        return unless args
+
+        args.children.each_with_index do |arg, idx|
+          if arg.type == :shadowarg
+            @shadow_args << arg
+          else
+            valid_args << arg
           end
         end
-      end
 
-      def args
-        sexp = if Fixnum === args_sexp or args_sexp.nil?
-          s(:args)
-        elsif args_sexp.is_a?(Sexp) && args_sexp.type == :lasgn
-          s(:args, s(:arg, *args_sexp[1]))
-        else
-          args_sexp[1]
-        end
+        @sexp = @sexp.updated(nil, [
+          args.updated(nil, valid_args),
+          body
+        ])
+      end
 
-        # compacting _ arguments into a single one (only the first one leaves in the sexp)
+      def extract_underscore_args
+        valid_args = []
         caught_blank_argument = false
 
-        sexp.each_with_index do |part, idx|
-          if part.is_a?(Sexp) && part.last == :_
-            if caught_blank_argument
-              sexp.delete_at(idx)
+        args.children.each do |arg|
+          arg_name = arg.children.first
+          if arg_name == :_
+            unless caught_blank_argument
+              caught_blank_argument = true
+              valid_args << arg
             end
-            caught_blank_argument = true
+          else
+            valid_args << arg
           end
         end
 
-        sexp
+        @sexp = @sexp.updated(nil, [
+          args.updated(nil, valid_args),
+          body
+        ])
       end
 
-      def body
-        compiler.returns(body_sexp || s(:nil))
+      def returned_body
+        compiler.returns(body || s(:nil))
       end
 
       def mlhs_args
@@ -151,7 +167,10 @@ module Opal
       end
 
       def has_trailing_comma_in_args?
-        args.meta[:has_trailing_comma]
+        if args.loc && args.loc.expression
+          args_source = args.loc.expression.source
+          args_source.match(/,\s*\|/)
+        end
       end
 
       # Returns code used in debug mode to check arity of method call
@@ -180,6 +199,12 @@ module Opal
           line "}"
         end
       end
+
+      def contains_break?
+        finder = Opal::Rewriters::BreakFinder.new
+        finder.process(@sexp)
+        finder.found_break?
+      end
     end
   end
 end

data/lib/opal/nodes/literal.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -52,7 +53,29 @@ module Opal
       end
 
       def compile
-        push translate_escape_chars(value.inspect)
+        sanitized_value = value.inspect.gsub(/\\u\{([0-9a-f]+)\}/) do |match|
+          code_point = $1.to_i(16)
+          to_utf16(code_point)
+        end
+        push translate_escape_chars(sanitized_value)
+      end
+
+      # http://www.2ality.com/2013/09/javascript-unicode.html
+      def to_utf16(code_point)
+        ten_bits = 0b1111111111
+        u = -> (code_unit) { '\\u'+code_unit.to_s(16).upcase }
+
+        return u.(code_point) if code_point <= 0xFFFF
+
+        code_point -= 0x10000
+
+        # Shift right to get to most significant 10 bits
+        lead_surrogate = 0xD800 + (code_point >> 10)
+
+        # Mask to get least significant 10 bits
+        tail_surrogate = 0xDC00 + (code_point & ten_bits)
+
+        u.(lead_surrogate) + u.(tail_surrogate)
       end
     end
 
@@ -69,16 +92,44 @@ module Opal
     class RegexpNode < Base
       handle :regexp
 
-      children :value, :flags
+      attr_accessor :value, :flags
+
+      # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+      SUPPORTED_FLAGS = /[gimuy]/
+
+      def initialize(*)
+        super
+        extract_flags_and_value
+      end
 
       def compile
-        flags = self.flags
-        flags = flags.gsub(/[^gimuy]/, '') if flags
+        flags.select! do |flag|
+          if SUPPORTED_FLAGS =~ flag
+            true
+          else
+            compiler.warning "Skipping the '#{flag}' Regexp flag as it's not widely supported by JavaScript vendors."
+            false
+          end
+        end
 
-        if flags != self.flags
-          warn "invalid js flags found #{self.flags.inspect}, replaced with #{flags.inspect}"
+        case value.type
+        when :dstr, :begin
+          compile_dynamic_regexp
+        when :str
+          compile_static_regexp
         end
+      end
 
+      def compile_dynamic_regexp
+        if flags.any?
+          push "new RegExp(", expr(value), ", '#{flags.join}')"
+        else
+          push "new RegExp(", expr(value), ')'
+        end
+      end
+
+      def compile_static_regexp
+        value = self.value.children[0]
         case value
         when ''
           push('/(?:)/')
@@ -86,74 +137,113 @@ module Opal
           message = "named captures are not supported in javascript: #{value.inspect}"
           push "self.$raise(new SyntaxError('#{message}'))"
         else
-          push "#{Regexp.new(value).inspect}#{flags}"
+          push "#{Regexp.new(value).inspect}#{flags.join}"
         end
       end
-    end
 
-    module XStringLineSplitter
-      def compile_split_lines(value, sexp)
-        idx = 0
-        value.each_line do |line|
-          if idx == 0
-            push line
-          else
-            line_sexp = s()
-            line_sexp.source = [sexp.line + idx, 0]
-            frag = Fragment.new(line, line_sexp)
-            push frag
+      def extract_flags_and_value
+        *values, flags_sexp = *children
+        self.flags = flags_sexp.children.map(&:to_s)
+
+        case values.length
+        when 0
+          # empty regexp, we can process it inline
+          self.value = s(:str, '')
+        when 1
+          # simple plain regexp, we can put it inline
+          self.value = values[0]
+        else
+          self.value = s(:dstr, *values)
+        end
+
+        # trimming when //x provided
+        # required by parser gem, but JS doesn't support 'x' flag
+        if flags.include?('x')
+          parts = value.children.map do |part|
+            if part.is_a?(::Opal::AST::Node) && part.type == :str
+              trimmed_value = part.children[0].gsub(/\A\s*\#.*/, '').gsub(/\s/, '')
+              s(:str, trimmed_value)
+            else
+              part
+            end
           end
 
-          idx += 1
+          self.value = value.updated(nil, parts)
+          flags.delete('x')
+        end
+
+        if value.type == :str
+          # Replacing \A -> ^, \z -> $, required for the parser gem
+          self.value = s(:str, value.children[0].gsub("\\A", "^").gsub("\\z", "$"))
         end
       end
-    end
 
-    class XStringNode < Base
-      include XStringLineSplitter
+      def raw_value
+        self.value = @sexp.loc.expression.source
+      end
+    end
 
-      handle :xstr
+    # $_ = 'foo'; call if /foo/
+    # s(:if, s(:match_current_line, /foo/, true))
+    class MatchCurrentLineNode < Base
+      handle :match_current_line
 
-      children :value
+      children :regexp
 
-      def needs_semicolon?
-        stmt? and !value.to_s.include?(';')
+      # Here we just convert it to
+      # ($_ =~ regexp)
+      # and let :send node to handle it
+      def compile
+        gvar_sexp = s(:gvar, :$_)
+        send_node = s(:send, gvar_sexp, :=~, regexp)
+        push expr(send_node)
       end
+    end
 
-      def compile
-        compile_split_lines(value.to_s, @sexp)
+    class XStringNode < Base
+      handle :xstr
 
-        push ';' if needs_semicolon?
+      def compile
+        children.each do |child|
+          case child.type
+          when :str
+            value = child.loc.expression.source
+            push Fragment.new(value, nil)
+          when :begin
+            push expr(child)
+          when :gvar, :ivar
+            push expr(child)
+          when :js_return
+            # A case for manually created :js_return statement in Compiler#returns
+            # Since we need to take original source of :str
+            # we have to use raw source
+            # so we need to combine "return" with "raw_source"
+            push "return "
+            str = child.children.first
+            value = str.loc.expression.source
+            push Fragment.new(value, nil)
+          else
+            raise "Unsupported xstr part: #{child.type}"
+          end
+        end
 
         wrap '(', ')' if recv?
       end
-
-      def start_line
-        @sexp.line
-      end
     end
 
     class DynamicStringNode < Base
       handle :dstr
 
       def compile
+        push '""'
+
         children.each_with_index do |part, idx|
-          push " + " unless idx == 0
-
-          if String === part
-            push part.inspect
-          elsif part.type == :evstr
-            push "("
-            push part[1] ? expr(part[1]) : '""'
-            push ")"
-          elsif part.type == :str
-            push part[1].inspect
-          elsif part.type == :dstr
-            push "("
-            push expr(part)
-            push ")"
+          push " + "
+
+          if part.type == :str
+            push part.children[0].inspect
           else
-            raise "Bad dstr part #{part.inspect}"
+            push "(", expr(part), ")"
           end
 
           wrap '(', ')' if recv?
@@ -161,101 +251,84 @@ module Opal
       end
     end
 
-    class DynamicSymbolNode < Base
+    class DynamicSymbolNode < DynamicStringNode
       handle :dsym
+    end
+
+    class RangeNode < Base
+      children :start, :finish
+
+      SIMPLE_CHILDREN_TYPES = [:int, :float, :str, :sym]
 
       def compile
-        children.each_with_index do |part, idx|
-          push " + " unless idx == 0
-
-          if String === part
-            push part.inspect
-          elsif part.type == :evstr
-            push expr(s(:call, part.last, :to_s, s(:arglist)))
-          elsif part.type == :str
-            push part.last.inspect
-          else
-            raise "Bad dsym part"
-          end
+        if compile_inline?
+          helper :range
+          compile_inline
+        else
+          compile_range_initialize
         end
-
-        wrap '(', ')'
       end
-    end
 
-    class DynamicXStringNode < Base
-      include XStringLineSplitter
+      def compile_inline?
+        start.type == finish.type &&
+          SIMPLE_CHILDREN_TYPES.include?(start.type) &&
+          SIMPLE_CHILDREN_TYPES.include?(finish.type)
+      end
 
-      handle :dxstr
+      def compile_inline
+        raise NotImplementedError
+      end
 
-      def requires_semicolon(code)
-        stmt? and !code.include?(';')
+      def compile_range_initialize
+        raise NotImplementedError
       end
+    end
 
-      def compile
-        needs_semicolon = false
-
-        children.each do |part|
-          if String === part
-            compile_split_lines(part.to_s, @sexp)
-
-            needs_semicolon = true if requires_semicolon(part.to_s)
-          elsif part.type == :evstr
-            push expr(part[1])
-          elsif part.type == :str
-            compile_split_lines(part.last.to_s, part)
-            needs_semicolon = true if requires_semicolon(part.last.to_s)
-          else
-            raise "Bad dxstr part"
-          end
-        end
+    class InclusiveRangeNode < RangeNode
+      handle :irange
 
-        push ';' if needs_semicolon
-        wrap '(', ')' if recv?
+      def compile_inline
+        push '$range(', expr(start), ', ', expr(finish), ', false)'
       end
-    end
 
-    class DynamicRegexpNode < Base
-      handle :dregx
+      def compile_range_initialize
+        push 'Opal.Range.$new(', expr(start), ', ', expr(finish), ', false)'
+      end
+    end
 
-      def compile
-        children.each_with_index do |part, idx|
-          push " + " unless idx == 0
+    class ExclusiveRangeNode < RangeNode
+      handle :erange
 
-          if String === part
-            push part.inspect
-          elsif part.type == :str
-            push part[1].inspect
-          else
-            push expr(part[1])
-          end
-        end
+      def compile_inline
+        push '$range(', expr(start), ', ', expr(finish), ', true)'
+      end
 
-        wrap '(new RegExp(', '))'
+      def compile_range_initialize
+        push 'Opal.Range.$new(', expr(start), ',' , expr(finish), ', true)'
       end
     end
 
-    class InclusiveRangeNode < Base
-      handle :irange
+    # 0b1111r -> s(:rational, (15/1))
+    # -0b1111r -> s(:rational, (-15/1))
+    class RationalNode < Base
+      handle :rational
 
-      children :start, :finish
+      children :value
 
       def compile
-        helper :range
-
-        push '$range(', expr(start), ', ', expr(finish), ', false)'
+        push "Opal.Rational.$new(#{value.numerator}, #{value.denominator})"
       end
     end
 
-    class ExclusiveRangeNode < Base
-      handle :erange
+    # 0b1110i -> s(:complex, (0+14i))
+    # -0b1110i -> s(:complex, (0-14i))
+    class ComplexNode < Base
+      handle :complex
 
-      children :start, :finish
+      children :value
 
       def compile
-        helper :range
-
-        push '$range(', expr(start), ', ', expr(finish), ', true)'
+        push "Opal.Complex.$new(#{value.real}, #{value.imag})"
       end
     end
   end