opal 0.10.0 → 0.11.0

data/lib/opal/nodes/literal.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -8,7 +9,7 @@ module Opal
       def compile
         push type.to_s
       end
-      
+
       def self.truthy_optimize?
         true
       end
@@ -23,7 +24,7 @@ module Opal
         push value.to_s
         wrap '(', ')' if recv?
       end
-      
+
       def self.truthy_optimize?
         true
       end
@@ -52,7 +53,41 @@ module Opal
       end
 
       def compile
-        push translate_escape_chars(value.inspect)
+        string_value = value
+        encoding = string_value.encoding
+        should_encode = encoding != Encoding::UTF_8
+
+        if should_encode
+          string_value = string_value.force_encoding('UTF-8')
+        end
+
+        sanitized_value = string_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)
+
+        if should_encode && RUBY_ENGINE != 'opal'
+          push '.$force_encoding("', encoding.name, '")'
+        end
+      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,9 +104,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.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
+
+        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('/(?:)/')
@@ -79,74 +149,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?
@@ -154,101 +263,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

data/lib/opal/nodes/logic.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -5,13 +6,24 @@ module Opal
     class NextNode < Base
       handle :next
 
-      children :value
-
       def compile
-        return push "continue;" if in_while?
+        if in_while?
+          push "continue;"
+        else
+          push expr_or_nil(value)
+          wrap "return ", ";"
+        end
+      end
 
-        push expr_or_nil(value)
-        wrap "return ", ";"
+      def value
+        case children.size
+        when 0
+          s(:nil)
+        when 1
+          children.first
+        else
+          s(:array, *children)
+        end
       end
     end
 
@@ -40,15 +52,13 @@ module Opal
 
       def compile_iter
         error "break must be used as a statement" unless stmt?
-        compiler.has_break!
+
         line 'Opal.brk(', break_val, ', $brk)'
       end
 
       def break_val
         if value.nil?
           expr(s(:nil))
-        elsif children.size > 1
-          expr(s(:array, *children))
         else
           expr(value)
         end
@@ -78,33 +88,18 @@ module Opal
       end
     end
 
-    class NotNode < Base
-      handle :not
-
-      children :value
-
-      def compile
-        with_temp do |tmp|
-          push expr(value)
-          wrap "(#{tmp} = ", ", (#{tmp} === nil || #{tmp} === false || #{tmp} == null))"
-        end
-      end
-    end
-
     class SplatNode < Base
       handle :splat
 
       children :value
 
       def empty_splat?
-        value == [:nil] or value == [:paren, [:nil]]
+        value == s(:array)
       end
 
       def compile
         if empty_splat?
           push '[]'
-        elsif value.type == :sym
-          push '[', expr(value), ']'
         else
           push "Opal.to_a(", recv(value), ")"
         end
@@ -135,25 +130,21 @@ module Opal
       children :lhs, :rhs
 
       def compile_ternary
+        helper :truthy
+
         with_temp do |tmp|
-          push "(((#{tmp} = "
-          push expr(lhs)
-          push ") !== false && #{tmp} !== nil && #{tmp} != null) ? #{tmp} : "
-          push expr(rhs)
-          push ")"
+          push "($truthy(#{tmp} = ", expr(lhs), ") ? #{tmp} : ", expr(rhs), ")"
         end
       end
 
       def compile_if
+        helper :truthy
+
         with_temp do |tmp|
-          push "if (#{tmp} = ", expr(lhs), ", #{tmp} !== false && #{tmp} !== nil && #{tmp} != null) {"
-          indent do
-            line tmp
-          end
+          push "if ($truthy(#{tmp} = ", expr(lhs), ")) {"
+          indent { line tmp }
           line "} else {"
-            indent do
-              line expr(rhs)
-            end
+          indent { line expr(rhs) }
           line "}"
         end
       end
@@ -174,31 +165,22 @@ module Opal
             push expr(rhs)
             push " : ", expr(lhs), ")"
           else
-            push "(#{tmp} = "
-            push expr(lhs)
-            push ", #{tmp} !== false && #{tmp} !== nil && #{tmp} != null ?"
-            push expr(rhs)
-            push " : #{tmp})"
+            helper :truthy
+
+            push "($truthy(#{tmp} = ", expr(lhs), ") ? ", expr(rhs), " : #{tmp})"
           end
         end
       end
 
       def compile_if
-        with_temp do |tmp|
-          if truthy_opt = js_truthy_optimize(lhs)
-            push "if (#{tmp} = ", truthy_opt, ") {"
-          else
-            push "if (#{tmp} = ", expr(lhs), ", #{tmp} !== false && #{tmp} !== nil && #{tmp} != null) {"
-          end
-          indent do
-            line expr(rhs)
-          end
-          line "} else {"
-          indent do
-            line expr(lhs)
-          end
-          line "}"
-        end
+        helper :truthy
+        condition = js_truthy_optimize(lhs) || expr(lhs)
+
+        line "if ($truthy(", condition, ")) {"
+        indent { line expr(rhs) }
+        line "} else {"
+        indent { line expr(lhs) }
+        line "}"
       end
     end
 
@@ -270,7 +252,7 @@ module Opal
       children :value
 
       def compile
-        push expr(s(:call, value, :to_proc, s(:arglist)))
+        push expr(s(:send, value, :to_proc, s(:arglist)))
       end
     end
   end

data/lib/opal/nodes/masgn.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
   module Nodes
     class MassAssignNode < Base
-      SIMPLE_ASSIGNMENT = [:lasgn, :iasgn, :lvar, :gasgn, :cdecl]
+      SIMPLE_ASSIGNMENT = [:lvasgn, :ivasgn, :lvar, :gvasgn, :cdecl, :casgn]
 
       handle :masgn
       children :lhs, :rhs
@@ -13,21 +14,23 @@ module Opal
 
         if rhs.type == :array
           push "#{array} = ", expr(rhs)
-          compile_masgn(lhs.children, array, rhs.size - 1)
+          rhs_len = rhs.children.any? { |c| c.type == :splat } ? nil : rhs.children.size
+          compile_masgn(lhs.children, array, rhs_len)
           push ", #{array}" # a mass assignment evaluates to the RHS
-        elsif rhs.type == :to_ary
+        elsif rhs.type == :begin
           retval = scope.new_temp
-          push "#{retval} = ", expr(rhs[1])
+          push "#{retval} = ", expr(rhs)
           push ", #{array} = Opal.to_ary(#{retval})"
           compile_masgn(lhs.children, array)
           push ", #{retval}"
           scope.queue_temp(retval)
-        elsif rhs.type == :splat
-          push "#{array} = Opal.to_a(", expr(rhs[1]), ")"
-          compile_masgn(lhs.children, array)
-          push ", #{array}"
         else
-          raise "unsupported mlhs type"
+          retval = scope.new_temp
+          push "#{retval} = ", expr(rhs)
+          push ", #{array} = Opal.to_ary(#{retval})"
+          compile_masgn(lhs.children, array)
+          push ", #{retval}"
+          scope.queue_temp(retval)
         end
 
         scope.queue_temp(array)
@@ -46,7 +49,7 @@ module Opal
           splat = post_splat.shift
 
           if post_splat.empty? # trailing splat
-            if part = splat[1]
+            if part = splat.children[0]
               part = part.dup << s(:js_tmp, "$slice.call(#{array}, #{pre_splat.size})")
               push ', '
               push expr(part)
@@ -56,7 +59,7 @@ module Opal
             push ", #{tmp} = #{array}.length - #{post_splat.size}"
             push ", #{tmp} = (#{tmp} < #{pre_splat.size}) ? #{pre_splat.size} : #{tmp}"
 
-            if part = splat[1]
+            if part = splat.children[0]
               part = part.dup << s(:js_tmp, "$slice.call(#{array}, #{pre_splat.size}, #{tmp})")
               push ', '
               push expr(part)
@@ -82,18 +85,17 @@ module Opal
           assign = s(:js_tmp, "#{array}[#{idx}]")
         end
 
-        part = child.dup
+        part = child.updated
         if SIMPLE_ASSIGNMENT.include?(child.type)
-          part << assign
-        elsif child.type == :call
-          part[2] = "#{part[2]}=".to_sym
-          part.last << assign
+          part = part.updated(nil, part.children + [assign])
+        elsif child.type == :send
+          part = part.updated(nil, part.children + [assign])
         elsif child.type == :attrasgn
           part.last << assign
-        elsif child.type == :array
+        elsif child.type == :mlhs
           # nested destructuring
           tmp = scope.new_temp
-          push ", (#{tmp} = Opal.to_ary(#{assign[1]})"
+          push ", (#{tmp} = Opal.to_ary(#{assign.children[0]})"
           compile_masgn(child.children, tmp)
           push ')'
           scope.queue_temp(tmp)