opal 1.0.3 → 1.1.1.rc1

data/lib/opal/nodes/masgn.rb

@@ -51,6 +51,7 @@ module Opal
 
           if post_splat.empty? # trailing splat
             if part = splat.children[0]
+              helper :slice
               part = part.dup << s(:js_tmp, "$slice.call(#{array}, #{pre_splat.size})")
               push ', '
               push expr(part)
@@ -61,6 +62,7 @@ module Opal
             push ", #{tmp} = (#{tmp} < #{pre_splat.size}) ? #{pre_splat.size} : #{tmp}"
 
             if part = splat.children[0]
+              helper :slice
               part = part.dup << s(:js_tmp, "$slice.call(#{array}, #{pre_splat.size}, #{tmp})")
               push ', '
               push expr(part)

data/lib/opal/nodes/rescue.rb

@@ -162,7 +162,7 @@ module Opal
         push 'if (Opal.rescue($err, ', expr(klasses), ')) {'
         indent do
           if lvar
-            push expr(lvar), '$err;'
+            push expr(lvar.updated(nil, [*lvar.children, s(:js_tmp, '$err')]))
           end
 
           # Need to ensure we clear the current exception out after the rescue block ends

data/lib/opal/nodes/super.rb

@@ -25,11 +25,12 @@ module Opal
       end
 
       def compile_using_send
-        helper :send
+        helper :send2
 
-        push '$send('
+        push '$send2('
         compile_receiver
-        compile_method
+        compile_method_body
+        compile_method_name
         compile_arguments
         compile_block_pass
         push ')'
@@ -71,12 +72,12 @@ module Opal
         def_scope.identify!(def_scope.mid)
       end
 
+      def allow_stubs
+        true
+      end
+
       def super_method_invocation
-        if def_scope.defs
-          "Opal.find_super_dispatcher(self, '#{method_id}', #{def_scope_identity}, #{defined_check_param}, self.$$class.$$prototype)"
-        else
-          "Opal.find_super_dispatcher(self, '#{method_id}', #{def_scope_identity}, #{defined_check_param})"
-        end
+        "Opal.find_super_dispatcher(self, '#{method_id}', #{def_scope_identity}, #{defined_check_param}, #{allow_stubs})"
       end
 
       def super_block_invocation
@@ -85,7 +86,7 @@ module Opal
         "Opal.find_iter_super_dispatcher(self, #{mid}, (#{trys} || #{cur_defn}), #{defined_check_param}, #{implicit_arguments_param})"
       end
 
-      def compile_method
+      def compile_method_body
         push ', '
         if scope.def?
           push super_method_invocation
@@ -95,14 +96,27 @@ module Opal
           raise 'super must be called from method body or block'
         end
       end
+
+      def compile_method_name
+        if scope.def?
+          push ", '#{method_id}'"
+        elsif scope.iter?
+          _chain, _cur_defn, mid = scope.super_chain
+          push ", #{mid}"
+        end
+      end
     end
 
     class DefinedSuperNode < BaseSuperNode
       handle :defined_super
 
+      def allow_stubs
+        false
+      end
+
       def compile
         compile_receiver
-        compile_method
+        compile_method_body
 
         wrap '((', ') != null ? "super" : nil)'
       end

data/lib/opal/nodes/top.rb

@@ -17,6 +17,8 @@ module Opal
 
         opening
         in_scope do
+          line '"use strict";' if compiler.use_strict?
+
           body_code = stmt(stmts)
           body_code = [body_code] unless body_code.is_a?(Array)
 
@@ -27,8 +29,8 @@ module Opal
             add_temp '$nesting = []'
           end
           add_temp 'nil = Opal.nil'
-          add_temp '$$$ = Opal.const_get_qualified'
-          add_temp '$$ = Opal.const_get_relative'
+          add_temp '$$$ = Opal.$$$'
+          add_temp '$$ = Opal.$$'
 
           add_used_helpers
           add_used_operators
@@ -75,8 +77,7 @@ module Opal
       end
 
       def add_used_helpers
-        helpers = compiler.helpers.to_a
-        helpers.to_a.each { |h| add_temp "$#{h} = Opal.#{h}" }
+        compiler.helpers.to_a.each { |h| add_temp "$#{h} = Opal.#{h}" }
       end
 
       def add_used_operators

data/lib/opal/parser/with_c_lexer.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+# There's no compatible c_lexer for parser 3.0.0.0 at this point...
 begin
   require 'c_lexer'
 rescue LoadError
-  $stderr.puts 'Failed to load WithCLexer, using pure Ruby lexer'
+  $stderr.puts 'Failed to load WithCLexer, using pure Ruby lexer' if $DEBUG
 end
 
 if defined? Parser::Ruby25WithWithCLexer

data/lib/opal/parser/with_ruby_lexer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Opal::Parser::WithRubyLexer < Parser::Ruby25
+class Opal::Parser::WithRubyLexer < Parser::Ruby30
   include Opal::Parser::DefaultConfig
   Opal::Parser.default_parser_class = self
 end

data/lib/opal/path_reader.rb

@@ -5,7 +5,7 @@ require 'opal/hike'
 
 module Opal
   class PathReader
-    RELATIVE_PATH_REGEXP = /#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}/
+    RELATIVE_PATH_REGEXP = /#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}/.freeze
     DEFAULT_EXTENSIONS = ['.js', '.js.rb', '.rb', '.opalerb'].freeze
 
     def initialize(paths = Opal.paths, extensions = DEFAULT_EXTENSIONS)
@@ -17,7 +17,7 @@ module Opal
     def read(path)
       full_path = expand(path)
       return nil if full_path.nil?
-      File.open(full_path, 'rb:UTF-8', &:read)
+      File.open(full_path, 'rb:UTF-8', &:read) if File.exist?(full_path)
     end
 
     def expand(path)

data/lib/opal/paths.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 module Opal
+  # We use this file from inside Opal as well, and __dir__ is not yet supported.
+  # rubocop:disable Style/ExpandPathArguments
   def self.gem_dir
-    File.expand_path('../..', __FILE__.dup.untaint)
+    File.expand_path('../..', __FILE__)
   end
 
   def self.core_dir
-    File.expand_path('../../../opal', __FILE__.dup.untaint)
+    File.expand_path('../../../opal', __FILE__)
   end
 
   def self.std_dir
-    File.expand_path('../../../stdlib', __FILE__.dup.untaint)
+    File.expand_path('../../../stdlib', __FILE__)
   end
+  # rubocop:enable Style/ExpandPathArguments
 
   # Add a file path to opals load path. Any gem containing ruby code that Opal
   # has access to should add a load path through this method. Load paths added
@@ -67,13 +70,13 @@ module Opal
   extend UseGem
 
   def self.paths
-    @paths.dup.freeze
+    @paths.freeze
   end
 
   # Resets Opal.paths to the default value
   # (includes `corelib`, `stdlib`, `opal/lib`, `ast` gem and `parser` gem)
   def self.reset_paths!
-    @paths = [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+    @paths = [core_dir, std_dir, gem_dir]
     if RUBY_ENGINE != 'opal'
       use_gem 'ast'
       use_gem 'parser'

data/lib/opal/repl.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'opal'
+
+module Opal
+  class REPL
+    HISTORY_PATH = File.expand_path('~/.opal-repl-history')
+
+    def initialize
+      begin
+        require 'mini_racer'
+      rescue LoadError
+        abort 'opal-repl depends on mini_racer gem, which is not currently installed'
+      end
+
+      begin
+        require 'readline'
+      rescue LoadError
+        abort 'opal-repl depends on readline, which is not currently available'
+      end
+
+      MiniRacer::Platform.set_flags! :harmony
+
+      @history = File.exist?(HISTORY_PATH)
+    end
+
+    def run(filename = nil)
+      load_opal
+      load_file(filename) if filename
+      load_history
+      run_input_loop
+    ensure
+      dump_history
+    end
+
+    def load_file(filename)
+      raise "file does not exist: #{filename}" unless File.exist? filename
+      eval_ruby File.read(filename)
+    end
+
+    def load_opal
+      v8.attach('console.log', method(:puts).to_proc)
+      v8.attach('console.warn', method(:warn).to_proc)
+      v8.eval Opal::Builder.new.build('opal').to_s
+      v8.attach('Opal.exit', method(:exit).to_proc)
+    end
+
+    def run_line(line)
+      result = eval_ruby(line)
+      puts "=> #{result}"
+    end
+
+    def run_input_loop
+      # on SIGINT lets just return from the loop..
+      previous_trap = trap('SIGINT') { return }
+
+      while (line = readline)
+        run_line(line)
+      end
+
+    ensure
+      trap('SIGINT', previous_trap || 'DEFAULT')
+    end
+
+    private
+
+    def eval_ruby(code)
+      builder = Opal::Builder.new
+      builder.build_str(code, '(irb)', irb: true, const_missing: true)
+      builder.processed[0...-1].each { |js_code| eval_js js_code.to_s }
+      last_processed_file = builder.processed.last.to_s
+      eval_js <<-JS
+        var $_result = #{last_processed_file};
+        $_result.$inspect()
+      JS
+    rescue => e
+      puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+
+    def eval_js(code)
+      v8.eval(code)
+    end
+
+    def v8
+      @v8 ||= MiniRacer::Context.new
+    end
+
+    def readline
+      Readline.readline '>> ', true
+    end
+
+    def load_history
+      return unless @history
+      File.read(HISTORY_PATH).lines.each { |line| Readline::HISTORY.push line.strip }
+    end
+
+    def dump_history
+      return unless @history
+      length = Readline::HISTORY.size > 1000 ? 1000 : Readline::HISTORY.size
+      File.write(HISTORY_PATH, Readline::HISTORY.to_a[-length..-1].join("\n"))
+    end
+  end
+end

data/lib/opal/rewriter.rb

@@ -12,6 +12,8 @@ require 'opal/rewriters/hashes/key_duplicates_rewriter'
 require 'opal/rewriters/dump_args'
 require 'opal/rewriters/mlhs_args'
 require 'opal/rewriters/inline_args'
+require 'opal/rewriters/numblocks'
+require 'opal/rewriters/returnable_logic'
 
 module Opal
   class Rewriter
@@ -42,6 +44,7 @@ module Opal
 
     use Rewriters::OpalEngineCheck
     use Rewriters::ForRewriter
+    use Rewriters::Numblocks
     use Rewriters::BlockToIter
     use Rewriters::DotJsSyntax
     use Rewriters::JsReservedWords
@@ -49,6 +52,7 @@ module Opal
     use Rewriters::BinaryOperatorAssignment
     use Rewriters::ExplicitWriterReturn
     use Rewriters::Hashes::KeyDuplicatesRewriter
+    use Rewriters::ReturnableLogic
     use Rewriters::DumpArgs
     use Rewriters::MlhsArgs
     use Rewriters::InlineArgs

data/lib/opal/rewriters/for_rewriter.rb

@@ -62,7 +62,7 @@ module Opal
 
         node = s(:send, iterating_value, :each,          # (0..3).each {
           s(:iter, s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
-            loop_body
+            process(loop_body)
           )
         )                                                #                          i = __jstmp; j = i + 1 }
 

data/lib/opal/rewriters/js_reserved_words.rb

@@ -8,25 +8,25 @@ module Opal
     class JsReservedWords < Base
       # Reserved javascript keywords - we cannot create variables with the
       # same name (ref: http://stackoverflow.com/a/9337272/601782)
-      ES51_RESERVED_WORD = /#{REGEXP_START}(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)#{REGEXP_END}/
+      ES51_RESERVED_WORD = /#{REGEXP_START}(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)#{REGEXP_END}/.freeze
 
       # ES3 reserved words that aren’t ES5.1 reserved words
-      ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/
+      ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/.freeze
 
       # Prototype special properties.
-      PROTO_SPECIAL_PROPS = /#{REGEXP_START}(?:constructor|displayName|__proto__|__parent__|__noSuchMethod__|__count__)#{REGEXP_END}/
+      PROTO_SPECIAL_PROPS = /#{REGEXP_START}(?:constructor|displayName|__proto__|__parent__|__noSuchMethod__|__count__)#{REGEXP_END}/.freeze
 
       # Prototype special methods.
-      PROTO_SPECIAL_METHODS = /#{REGEXP_START}(?:hasOwnProperty|valueOf)#{REGEXP_END}/
+      PROTO_SPECIAL_METHODS = /#{REGEXP_START}(?:hasOwnProperty|valueOf)#{REGEXP_END}/.freeze
 
       # Immutable properties of the global object
-      IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/
+      IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/.freeze
 
       # Doesn't take in account utf8
-      BASIC_IDENTIFIER_RULES = /#{REGEXP_START}[$_a-z][$_a-z\d]*#{REGEXP_END}/i
+      BASIC_IDENTIFIER_RULES = /#{REGEXP_START}[$_a-z][$_a-z\d]*#{REGEXP_END}/i.freeze
 
       # Defining a local function like Array may break everything
-      RESERVED_FUNCTION_NAMES = /#{REGEXP_START}(?:Array)#{REGEXP_END}/
+      RESERVED_FUNCTION_NAMES = /#{REGEXP_START}(?:Array)#{REGEXP_END}/.freeze
 
       def self.valid_name?(name)
         BASIC_IDENTIFIER_RULES =~ name && !(

data/lib/opal/rewriters/numblocks.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    # This rewriter transforms the Ruby 2.7 numblocks to regular blocks:
+    #
+    # proc { _1 }
+    #      v
+    # proc { |_1| _1 }
+    class Numblocks < Base
+      def on_numblock(node)
+        left, arg_count, right = node.children
+
+        s(
+          :block,
+          left,
+          s(:args, *gen_args(arg_count)),
+          right
+        )
+      end
+
+      def gen_args(arg_count)
+        (1..arg_count).map do |i|
+          s(:arg, :"_#{i}")
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/returnable_logic.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ReturnableLogic < Base
+      def next_tmp
+        @counter ||= 0
+        @counter += 1
+        "$ret_or_#{@counter}"
+      end
+
+      def reset_tmp_counter!
+        @counter = nil
+      end
+
+      def on_or(node)
+        lhs, rhs = *node.children
+        lhs_tmp = next_tmp
+
+        node.updated(:if, [s(:lvasgn, lhs_tmp, process(lhs)), s(:js_tmp, lhs_tmp), process(rhs)])
+      end
+
+      def on_and(node)
+        lhs, rhs = *node.children
+        lhs_tmp = next_tmp
+
+        node.updated(:if, [s(:lvasgn, lhs_tmp, process(lhs)), process(rhs), s(:js_tmp, lhs_tmp)])
+      end
+    end
+  end
+end