opal 1.1.1 → 1.2.0.beta1

data/lib/opal/compiler.rb

@@ -151,7 +151,7 @@ module Opal
 
     # @!method use_strict?
     #
-    # Adds source_location for every method definition
+    # Enables JavaScript's strict mode (i.e., adds 'use strict'; statement)
     compiler_option :use_strict, default: false, as: :use_strict?, magic_comment: true
 
     # @!method parse_comments?
@@ -358,7 +358,7 @@ module Opal
     def in_while
       return unless block_given?
       @while_loop = @scope.push_while
-      result = indent { yield }
+      result = yield
       @scope.pop_while
       result
     end

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

@@ -21,6 +21,7 @@ module Opal
         @kwargs    = arguments.kwargs
         @kwoptargs = arguments.kwoptargs
         @kwrestarg = arguments.kwrestarg
+        @kwnilarg  = arguments.kwnilarg
       end
 
       def compile

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

@@ -30,6 +30,7 @@ module Opal
 
         def on_restarg(arg_name = nil)
           if arg_name
+            arg_name = :* if arg_name == :fwd_rest_arg
             %{['rest', '#{arg_name}']}
           else
             %{['rest']}
@@ -53,9 +54,14 @@ module Opal
         end
 
         def on_blockarg(arg_name)
+          arg_name = :& if arg_name == :fwd_block_arg
           %{['block', '#{arg_name}']}
         end
 
+        def on_kwnilarg
+          %{['nokey']}
+        end
+
         def on_shadowarg(_arg_name); end
       end
     end

data/lib/opal/nodes/class.rb

@@ -15,28 +15,16 @@ module Opal
 
         push '(function($base, $super, $parent_nesting) {'
         line "  var self = $klass($base, $super, '#{name}');"
-
         in_scope do
           scope.name = name
-          add_temp '$nesting = [self].concat($parent_nesting)'
-
-          body_code = self.body_code
-          empty_line
-
-          line scope.to_vars
-          line body_code
+          compile_body
         end
-
         line '})(', base, ', ', super_code, ', $nesting)'
       end
 
       def super_code
         sup ? expr(sup) : 'null'
       end
-
-      def body_code
-        stmt(compiler.returns(body || s(:nil)))
-      end
     end
   end
 end

data/lib/opal/nodes/literal.rb

@@ -70,6 +70,11 @@ module Opal
             wrap "$enc(", ", \"#{encoding.name}\")"
           end
         end
+
+        unless value.valid_encoding?
+          helper :binary
+          wrap "$binary(", ")"
+        end
       end
 
       # http://www.2ality.com/2013/09/javascript-unicode.html
@@ -253,9 +258,11 @@ module Opal
       end
 
       def compile_inline?
-        start.type == finish.type &&
-          SIMPLE_CHILDREN_TYPES.include?(start.type) &&
-          SIMPLE_CHILDREN_TYPES.include?(finish.type)
+        (
+          !start || (start.type && SIMPLE_CHILDREN_TYPES.include?(start.type))
+        ) && (
+          !finish || (finish.type && SIMPLE_CHILDREN_TYPES.include?(finish.type))
+        )
       end
 
       def compile_inline
@@ -271,11 +278,11 @@ module Opal
       handle :irange
 
       def compile_inline
-        push '$range(', expr(start), ', ', expr(finish), ', false)'
+        push '$range(', expr_or_nil(start), ', ', expr_or_nil(finish), ', false)'
       end
 
       def compile_range_initialize
-        push 'Opal.Range.$new(', expr(start), ', ', expr(finish), ', false)'
+        push 'Opal.Range.$new(', expr_or_nil(start), ', ', expr_or_nil(finish), ', false)'
       end
     end
 
@@ -283,11 +290,11 @@ module Opal
       handle :erange
 
       def compile_inline
-        push '$range(', expr(start), ', ', expr(finish), ', true)'
+        push '$range(', expr_or_nil(start), ', ', expr_or_nil(finish), ', true)'
       end
 
       def compile_range_initialize
-        push 'Opal.Range.$new(', expr(start), ',', expr(finish), ', true)'
+        push 'Opal.Range.$new(', expr_or_nil(start), ',', expr_or_nil(finish), ', true)'
       end
     end
 

data/lib/opal/nodes/module.rb

@@ -15,21 +15,15 @@ module Opal
 
         push '(function($base, $parent_nesting) {'
         line "  var self = $module($base, '#{name}');"
-
         in_scope do
           scope.name = name
-          add_temp '$nesting = [self].concat($parent_nesting)'
-
-          body_code = stmt(body || s(:nil))
-          empty_line
-
-          line scope.to_vars
-          line body_code
+          compile_body
         end
-
         line '})(', base, ', $nesting)'
       end
 
+      private
+
       # cid is always s(:const, scope_sexp_or_nil, :ConstName)
       def name_and_base
         base, name = cid.children
@@ -40,6 +34,16 @@ module Opal
           [name, expr(base)]
         end
       end
+
+      def compile_body
+        add_temp '$nesting = [self].concat($parent_nesting)'
+
+        body_code = stmt(compiler.returns(body || s(:nil)))
+        empty_line
+
+        line scope.to_vars
+        line body_code
+      end
     end
   end
 end

data/lib/opal/nodes/variables.rb

@@ -194,9 +194,16 @@ module Opal
       children :name
 
       def compile
-        with_temp do |tmp|
-          push "((#{tmp} = #{class_variable_owner}.$$cvars['#{name}']) == null ? nil : #{tmp})"
-        end
+        helper :class_variable_get
+
+        tolerant = false
+        # We should be tolerant of expressions like: def x; @@notexist; 0; end
+        # (NB: Shouldn't we actually optimize them out?)
+        tolerant = true if stmt?
+        # We should be tolerant of expressions like: @@notexist ||= 6
+        # (those are handled with logical_operator_assignment)
+
+        push "$class_variable_get(#{class_variable_owner}, '#{name}', #{tolerant.inspect})"
       end
     end
 
@@ -206,7 +213,9 @@ module Opal
       children :name, :value
 
       def compile
-        push "(Opal.class_variable_set(#{class_variable_owner}, '#{name}', ", expr(value), '))'
+        helper :class_variable_set
+
+        push "$class_variable_set(#{class_variable_owner}, '#{name}', ", expr(value), ')'
       end
     end
   end

data/lib/opal/nodes/while.rb

@@ -10,32 +10,45 @@ module Opal
       children :test, :body
 
       def compile
-        with_temp do |redo_var|
-          test_code = js_truthy(test)
+        test_code = js_truthy(test)
 
+        with_temp do |redo_var|
           compiler.in_while do
             while_loop[:closure] = true if wrap_in_closure?
             while_loop[:redo_var] = redo_var
 
-            body_code = stmt(body)
-
+            body_code = indent { stmt(body) }
             if uses_redo?
-              push "#{redo_var} = false; #{while_open}#{redo_var} || "
-              push test_code
-              push while_close
+              compile_with_redo(test_code, body_code, redo_var)
             else
-              push while_open, test_code, while_close
+              compile_without_redo(test_code, body_code)
             end
-
-            push "#{redo_var} = false;" if uses_redo?
-            line body_code
           end
-          line '}'
         end
 
         wrap '(function() {', '; return nil; })()' if wrap_in_closure?
       end
 
+      private
+
+      def compile_with_redo(test_code, body_code, redo_var)
+        push "#{redo_var} = false; "
+        compile_while(
+          [redo_var, " || ", test_code],
+          ["#{redo_var} = false;", body_code]
+        )
+      end
+
+      def compile_without_redo(test_code, body_code)
+        compile_while([test_code], [body_code])
+      end
+
+      def compile_while(test_code, body_code)
+        push while_open, *test_code, while_close
+        indent { line(*body_code) }
+        line '}'
+      end
+
       def while_open
         'while ('
       end
@@ -53,13 +66,11 @@ module Opal
       end
     end
 
-    class WhilePostNode < WhileNode
-      handle :while_post
-    end
-
     class UntilNode < WhileNode
       handle :until
 
+      private
+
       def while_open
         'while (!('
       end
@@ -69,8 +80,34 @@ module Opal
       end
     end
 
-    class UntilPostNode < UntilNode
+    class WhilePostNode < WhileNode
+      handle :while_post
+
+      private
+
+      def compile_while(test_code, body_code)
+        push "do {"
+        indent { line(*body_code) }
+        line "} ", while_open, *test_code, while_close
+      end
+
+      def while_close
+        ');'
+      end
+    end
+
+    class UntilPostNode < WhilePostNode
       handle :until_post
+
+      private
+
+      def while_open
+        'while(!('
+      end
+
+      def while_close
+        '));'
+      end
     end
   end
 end

data/lib/opal/parser.rb

@@ -6,8 +6,4 @@ require 'opal/parser/source_buffer'
 require 'opal/parser/default_config'
 require 'opal/parser/with_ruby_lexer'
 
-if RUBY_ENGINE == 'opal'
-  require 'opal/parser/patch'
-else
-  require 'opal/parser/with_c_lexer'
-end
+require 'opal/parser/patch'

data/lib/opal/parser/patch.rb

@@ -39,3 +39,37 @@ if RUBY_ENGINE == 'opal'
     end
   end
 end
+
+module AST::Processor::Mixin
+  undef process
+  # This patch to #process removes a bit of dynamic abilities (removed
+  # call to node.to_ast) and it tries to optimize away the string
+  # operations and method existence check by caching them inside a
+  # processor.
+  #
+  # This is the second most inefficient call in the compilation phase
+  # so an optimization may be warranted.
+  def process(node)
+    return if node.nil?
+
+    @_on_handler_cache ||= {}
+    type = node.type
+
+    on_handler = @_on_handler_cache[type] ||= begin
+      handler = :"on_#{type}"
+      handler = :handler_missing unless respond_to?(handler)
+      handler
+    end
+
+    send(on_handler, node) || node
+  end
+end
+
+class Parser::Builders::Default
+  # string_value raises on invalid UTF-8 strings, like "\x80",
+  # otherwise it's the same as value.
+  undef string_value
+  def string_value(token)
+    value(token)
+  end
+end

data/lib/opal/repl.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'opal'
+require 'securerandom'
 
 module Opal
   class REPL
@@ -38,9 +39,15 @@ module Opal
       eval_ruby File.read(filename)
     end
 
+    # A polyfill so that SecureRandom works in repl correctly.
+    def random_bytes(bytes)
+      ::SecureRandom.bytes(bytes).split('').map(&:ord)
+    end
+
     def load_opal
       v8.attach('console.log', method(:puts).to_proc)
       v8.attach('console.warn', method(:warn).to_proc)
+      v8.attach('crypto.randomBytes', method(:random_bytes).to_proc)
       v8.eval Opal::Builder.new.build('opal').to_s
       v8.attach('Opal.exit', method(:exit).to_proc)
     end

data/lib/opal/rewriter.rb

@@ -14,6 +14,7 @@ require 'opal/rewriters/mlhs_args'
 require 'opal/rewriters/inline_args'
 require 'opal/rewriters/numblocks'
 require 'opal/rewriters/returnable_logic'
+require 'opal/rewriters/forward_args'
 
 module Opal
   class Rewriter
@@ -45,6 +46,7 @@ module Opal
     use Rewriters::OpalEngineCheck
     use Rewriters::ForRewriter
     use Rewriters::Numblocks
+    use Rewriters::ForwardArgs
     use Rewriters::BlockToIter
     use Rewriters::DotJsSyntax
     use Rewriters::JsReservedWords

data/lib/opal/rewriters/arguments.rb

@@ -4,7 +4,7 @@ module Opal
   module Rewriters
     class Arguments
       attr_reader :args, :optargs, :restarg, :postargs,
-        :kwargs, :kwoptargs, :kwrestarg,
+        :kwargs, :kwoptargs, :kwrestarg, :kwnilarg,
         :shadowargs, :blockarg
 
       def initialize(args)
@@ -15,6 +15,7 @@ module Opal
         @kwargs = []
         @kwoptargs = []
         @kwrestarg = nil
+        @kwnilarg = false
         @shadowargs = []
         @blockarg = nil
 
@@ -30,6 +31,8 @@ module Opal
             @kwargs << arg
           when :kwoptarg
             @kwoptargs << arg
+          when :kwnilarg
+            @kwnilarg = true
           when :kwrestarg
             @kwrestarg = arg
           when :shadowarg

data/lib/opal/rewriters/forward_args.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ForwardArgs < Base
+      def on_forward_args(_node)
+        process(
+          s(:args, s(:forward_arg, :"$"))
+        )
+      end
+
+      def on_args(node)
+        if node.children.last && node.children.last.type == :forward_arg
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:restarg, '$fwd_rest'),
+              s(:blockarg, '$fwd_block')
+            ]
+          )
+        else
+          super
+        end
+      end
+
+      def on_send(node)
+        if node.children.last &&
+           node.children.last.class != Symbol &&
+           node.children.last.type == :forwarded_args
+
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:splat,
+                s(:lvar, '$fwd_rest')
+              ),
+              s(:block_pass,
+                s(:lvar, '$fwd_block')
+              )
+            ]
+          )
+        else
+          super
+        end
+      end
+    end
+  end
+end