opal 1.2.0 → 1.3.0.alpha1

data/lib/opal/cli_runners/source-map-support.js

@@ -3,7 +3,7 @@
 // to do so, `run bin/build-browser-source-map-support`
 
 // The following is taken and adapted from the work of Evan Wallace
-// https://github.com/evanw/node-source-map-support v0.5.12
+// https://github.com/evanw/node-source-map-support v0.5.19
 
 // The MIT License (MIT)
 //
@@ -43,6 +43,16 @@ try {
 
 var bufferFrom = require('buffer-from');
 
+/**
+ * Requires a module which is protected against bundler minification.
+ *
+ * @param {NodeModule} mod
+ * @param {string} request
+ */
+function dynamicRequire(mod, request) {
+  return mod.require(request);
+}  
+
 // Only install once if called multiple times
 var errorFormatterInstalled = false;
 var uncaughtShimInstalled = false;
@@ -169,7 +179,7 @@ function retrieveSourceMapURL(source) {
 
   // Get the URL of the source map
   fileData = retrieveFile(source);
-  var re = /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^\*]+?)[ \t]*(?:\*\/)[ \t]*$)/mg;
+  var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
   // Keep executing the search to find the *last* sourceMappingURL to avoid
   // picking up sourceMappingURLs from comments, strings, etc.
   var lastMatch, match;
@@ -380,8 +390,13 @@ function cloneCallSite(frame) {
   return object;
 }
 
-function wrapCallSite(frame) {
+function wrapCallSite(frame, state) {
+  // provides interface backward compatibility
+  if (state === undefined) {
+    state = { nextPosition: null, curPosition: null }
+  }
   if(frame.isNative()) {
+    state.curPosition = null;
     return frame;
   }
 
@@ -395,7 +410,11 @@ function wrapCallSite(frame) {
 
     // Fix position in Node where some (internal) code is prepended.
     // See https://github.com/evanw/node-source-map-support/issues/36
-    var headerLength = 62;
+    // Header removed in node at ^10.16 || >=11.11.0
+    // v11 is not an LTS candidate, we can just test the one version with it.
+    // Test node versions for: 10.16-19, 10.20+, 12-19, 20-99, 100+, or 11.11
+    var noHeader = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/;
+    var headerLength = noHeader.test(process.version) ? 0 : 62;
     if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
       column -= headerLength;
     }
@@ -405,9 +424,15 @@ function wrapCallSite(frame) {
       line: line,
       column: column
     });
+    state.curPosition = position;
     frame = cloneCallSite(frame);
     var originalFunctionName = frame.getFunctionName;
-    frame.getFunctionName = function() { return position.name || originalFunctionName(); };
+    frame.getFunctionName = function() {
+      if (state.nextPosition == null) {
+        return originalFunctionName();
+      }
+      return state.nextPosition.name || originalFunctionName();
+    };
     frame.getFileName = function() { return position.source; };
     frame.getLineNumber = function() { return position.line; };
     frame.getColumnNumber = function() { return position.column + 1; };
@@ -440,9 +465,14 @@ function prepareStackTrace(error, stack) {
   var message = error.message || '';
   var errorString = name + ": " + message;
 
-  return errorString + stack.map(function(frame) {
-    return '\n  from ' + wrapCallSite(frame);
-  }).join('');
+  var state = { nextPosition: null, curPosition: null };
+  var processedStack = [];
+  for (var i = stack.length - 1; i >= 0; i--) {
+    processedStack.push('\n  from ' + wrapCallSite(stack[i], state));
+    state.nextPosition = state.curPosition;
+  }
+  state.curPosition = state.nextPosition = null;
+  return errorString + processedStack.reverse().join('');
 }
 
 // Generate position and snippet of original source with pointer
@@ -485,12 +515,17 @@ function printErrorAndExit (error) {
     process.stderr._handle.setBlocking(true);
   }
 
-  if (source) {
-    console.error();
-    console.error(source);
+  if (typeof error.$full_message === 'function') {
+    console.error(error.$full_message().$chomp());
   }
+  else {
+    if (source) {
+      console.error();
+      console.error(source);
+    }
 
-  console.error(error.stack);
+    console.error(error.stack);
+  }
   process.exit(1);
 }
 
@@ -551,12 +586,8 @@ exports.install = function(options) {
 
   // Support runtime transpilers that include inline source maps
   if (options.hookRequire && !isInBrowser()) {
-    var Module;
-    try {
-      Module = require('module');
-    } catch (err) {
-      // NOP: Loading in catch block to convert webpack error to warning.
-    }
+    // Use dynamicRequire to avoid including in browser bundles
+    var Module = dynamicRequire(module, 'module');
     var $compile = Module.prototype._compile;
 
     if (!$compile.__sourceMapSupport) {
@@ -586,6 +617,17 @@ exports.install = function(options) {
     var installHandler = 'handleUncaughtExceptions' in options ?
       options.handleUncaughtExceptions : true;
 
+    // Do not override 'uncaughtException' with our own handler in Node.js
+    // Worker threads. Workers pass the error to the main thread as an event,
+    // rather than printing something to stderr and exiting.
+    try {
+      // We need to use `dynamicRequire` because `require` on it's own will be optimized by WebPack/Browserify.
+      var worker_threads = dynamicRequire(module, 'worker_threads');
+      if (worker_threads.isMainThread === false) {
+        installHandler = false;
+      }
+    } catch(e) {}      
+
     // Provide the option to not install the uncaught exception handler. This is
     // to support other uncaught exception handlers (in test frameworks, for
     // example). If this handler is not installed and there are no other uncaught

data/lib/opal/cli_runners.rb

@@ -65,6 +65,8 @@ module Opal
     register_runner :compiler,    :Compiler,    'opal/cli_runners/compiler'
     register_runner :nashorn,     :Nashorn,     'opal/cli_runners/nashorn'
     register_runner :nodejs,      :Nodejs,      'opal/cli_runners/nodejs'
+    register_runner :gjs,         :Gjs,         'opal/cli_runners/gjs'
+    register_runner :miniracer,   :MiniRacer,   'opal/cli_runners/mini_racer'
     register_runner :server,      :Server,      'opal/cli_runners/server'
 
     alias_runner :osascript, :applescript

data/lib/opal/compiler.rb

@@ -137,6 +137,11 @@ module Opal
     # Prepare the code for future requires
     compiler_option :requirable, default: false, as: :requirable?
 
+    # @!method esm?
+    #
+    # Wrap compiler result as self contained ES6 module
+    compiler_option :esm, default: false, as: :esm?
+
     # @!method inline_operators?
     #
     # are operators compiled inline
@@ -159,6 +164,38 @@ module Opal
     # Adds comments for every method definition
     compiler_option :parse_comments, default: false, as: :parse_comments?
 
+    compiler_option :scope_variables, default: []
+
+    # @!method async_await
+    #
+    # Enable async/await support and optionally enable auto-await.
+    #
+    # Use either true, false, an Array of Symbols, a String containing names
+    # to auto-await separated by a comma or a Regexp.
+    #
+    # Auto-await awaits provided methods by default as if .__await__ was added to
+    # them automatically.
+    #
+    # By default, the support is disabled (set to false).
+    #
+    # If the config value is not set to false, any calls to #__await__ will be
+    # translated to ES8 await keyword which makes the scope return a Promise
+    # and a containing scope will be async (instead of a value, it will return
+    # a Promise).
+    #
+    # If the config value is an array, or a String separated by a comma,
+    # auto-await is also enabled.
+    #
+    # A member of this collection can contain a wildcard character * in which
+    # case all methods containing a given substring will be awaited.
+    #
+    # It can be used as a magic comment, examples:
+    # ```
+    # # await: true
+    # # await: *await*
+    # # await: *await*, sleep, gets
+    compiler_option :await, default: false, as: :async_await, magic_comment: true
+
     # @return [String] The compiled ruby code
     attr_reader :result
 
@@ -211,7 +248,16 @@ module Opal
 
       sexp, comments, tokens = re_raise_with_location { @parser.tokenize(@buffer) }
 
-      @sexp = s(:top, sexp || s(:nil))
+      kind = case
+             when requirable?
+               :require
+             when eval?
+               :eval
+             else
+               :main
+             end
+
+      @sexp = s(:top, sexp || s(:nil)).tap { |i| i.meta[:kind] = kind }
       @comments = ::Parser::Source::Comment.associate_locations(sexp, comments)
       @magic_comments = MagicComments.parse(sexp, comments)
       @eof_content = EofContent.new(tokens, @source).eof
@@ -223,7 +269,8 @@ module Opal
     # @param source_file [String] optional source_file to reference ruby source
     # @return [Opal::SourceMap]
     def source_map
-      ::Opal::SourceMap::File.new(@fragments, file, @source)
+      # We only use @source_map if compiler is cached.
+      @source_map || ::Opal::SourceMap::File.new(@fragments, file, @source, @result)
     end
 
     # Any helpers required by this file. Used by {Opal::Nodes::Top} to reference
@@ -247,6 +294,32 @@ module Opal
       @method_calls ||= Set.new
     end
 
+    alias async_await_before_typecasting async_await
+    def async_await
+      if defined? @async_await
+        @async_await
+      else
+        original = async_await_before_typecasting
+        @async_await = case original
+                       when String
+                         async_await_set_to_regexp(original.split(',').map { |h| h.strip.to_sym })
+                       when Array, Set
+                         async_await_set_to_regexp(original.to_a.map(&:to_sym))
+                       when Regexp, true, false
+                         original
+                       else
+                         raise 'A value of await compiler option can be either ' \
+                               'a Set, an Array, a String or a Boolean.'
+                       end
+      end
+    end
+
+    def async_await_set_to_regexp(set)
+      set = set.map { |name| Regexp.escape(name.to_s).gsub('\*', '.*?') }
+      set = set.join('|')
+      /^(#{set})$/
+    end
+
     # This is called when a parsing/processing error occurs. This
     # method simply appends the filename and curent line number onto
     # the message and raises it.
@@ -421,8 +494,8 @@ module Opal
       case sexp.type
       when :undef
         # undef :method_name always returns nil
-        returns s(:begin, sexp, s(:nil))
-      when :break, :next, :redo
+        returns sexp.updated(:begin, [sexp, s(:nil)])
+      when :break, :next, :redo, :retry
         sexp
       when :yield
         sexp.updated(:returnable_yield, nil)
@@ -453,7 +526,7 @@ module Opal
       when :ensure
         rescue_sexp, ensure_body = *sexp
         sexp = sexp.updated(nil, [returns(rescue_sexp), ensure_body])
-        s(:js_return, sexp)
+        sexp.updated(:js_return, [sexp])
       when :begin, :kwbegin
         # Wrapping last expression with s(:js_return, ...)
         *rest, last = *sexp
@@ -474,11 +547,14 @@ module Opal
           ]
         )
       else
-        s(:js_return, sexp).updated(
-          nil,
-          nil,
-          location: sexp.loc,
-        )
+        if sexp.type == :send && sexp.children[1] == :debugger
+          # debugger is a statement, so it doesn't return a value
+          # and returning it is invalid. Therefore we update it
+          # to do `debugger; return nil`.
+          sexp.updated(:begin, [sexp, s(:js_return, s(:nil))])
+        else
+          sexp.updated(:js_return, [sexp])
+        end
       end
     end
 
@@ -492,5 +568,18 @@ module Opal
         fragment('false', scope, sexp)
       end
     end
+
+    # Marshalling for cache shortpath
+    def marshal_dump
+      [@options, @option_values, @source_map ||= source_map.cache,
+       @magic_comments, @result,
+       @required_trees, @requires]
+    end
+
+    def marshal_load(src)
+      @options, @option_values, @source_map,
+      @magic_comments, @result,
+      @required_trees, @requires = src
+    end
   end
 end

data/lib/opal/fragment.rb

@@ -28,41 +28,104 @@ module Opal
       "f(#{@code.inspect})"
     end
 
-    def source_map_name
-      case @sexp.type
-      when :top, :begin, :newline, :js_return
-        nil
+    def source_map_name_for(sexp)
+      case sexp.type
+      when :top
+        case sexp.meta[:kind]
+        when :require
+          '<top (required)>'
+        when :eval
+          '(eval)'
+        when :main
+          '<main>'
+        end
+      when :begin, :newline, :js_return
+        source_map_name_for(@scope.sexp) if @scope
+      when :iter
+        scope = @scope
+        iters = 1
+        while scope
+          if scope.class == Nodes::IterNode
+            iters += 1
+            scope = scope.parent
+          else
+            break
+          end
+        end
+        level = " (#{iters} levels)" if iters > 1
+        "block#{level} in #{source_map_name_for(scope.sexp)}"
       when :self
         'self'
       when :module
-        'module'
+        const, = *sexp
+        "<module:#{source_map_name_for(const)}>"
       when :class
-        'class'
+        const, = *sexp
+        "<class:#{source_map_name_for(const)}>"
+      when :const
+        scope, name = *sexp
+        if !scope || scope.type == :cbase
+          name.to_s
+        else
+          "#{source_map_name_for(scope)}::#{name}"
+        end
       when :int
-        @sexp.children.first
+        sexp.children.first
       when :def
-        @sexp.children.first
+        sexp.children.first
       when :defs
-        @sexp.children[1]
+        sexp.children[1]
       when :send
-        @sexp.children[1]
-      when :lvar, :lvasgn, :lvdeclare, :ivar, :ivasgn, :gvar, :cvar, :cvasgn, :gvars, :gvasgn
-        @sexp.children.first
+        sexp.children[1]
+      when :lvar, :lvasgn, :lvdeclare, :ivar, :ivasgn, :gvar, :cvar, :cvasgn, :gvars, :gvasgn, :arg
+        sexp.children.first
+      when :str, :xstr # Inside xstr - JS calls
+        source_map_name_for(@scope.sexp)
       else
         # nil
       end
     end
 
+    def source_map_name
+      return nil unless @sexp
+
+      source_map_name_for(@sexp)
+    end
+
+    def location
+      case
+      when !@sexp
+        nil
+      when @sexp.type == :send
+        loc = @sexp.loc
+        if loc.respond_to? :dot # a>.b || a>+b / >a / a>[b]
+          loc.dot || loc.selector
+        elsif loc.respond_to? :operator # a >|= b
+          loc.operator
+        else
+          @sexp
+        end
+      when @sexp.type == :iter
+        @sexp.loc.begin # [1,2].each >{ }
+      else
+        @sexp
+      end
+    end
+
     # Original line this fragment was created from
     # @return [Integer, nil]
     def line
-      @sexp.line if @sexp
+      location&.line
     end
 
     # Original column this fragment was created from
     # @return [Integer, nil]
     def column
-      @sexp.column if @sexp
+      location&.column
+    end
+
+    def skip_source_map?
+      @sexp == false
     end
   end
 end

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

@@ -16,10 +16,12 @@ module Opal
         children :name
 
         def compile
-          if name
-            add_temp name
-            line "#{name} = Opal.kwrestargs($kwargs, #{used_kwargs});"
-          end
+          # def m(**)
+          # arguments are assigned to `$kw_rest_arg` for super call
+          name = self.name || '$kw_rest_arg'
+
+          add_temp name
+          line "#{name} = Opal.kwrestargs($kwargs, #{used_kwargs});"
         end
 
         def used_kwargs

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

@@ -19,19 +19,17 @@ module Opal
         children :name, :args_to_keep
 
         def compile
-          if name
-            add_temp name
+          # def m(*)
+          # arguments are assigned to `$rest_arg` for super call
+          name = self.name || '$rest_arg'
 
-            if args_to_keep == 0
-              # no post-args, we are free to grab everything
-              line "#{name} = $post_args;"
-            else
-              line "#{name} = $post_args.splice(0, $post_args.length - #{args_to_keep});"
-            end
-          elsif args_to_keep != 0
-            # def m(*, a)
-            # We still have to "cut" our splat
-            line "$post_args.splice(0, $post_args.length - #{args_to_keep});"
+          add_temp name
+
+          if args_to_keep == 0
+            # no post-args, we are free to grab everything
+            line "#{name} = $post_args;"
+          else
+            line "#{name} = $post_args.splice(0, $post_args.length - #{args_to_keep});"
           end
         end
       end

data/lib/opal/nodes/args.rb

@@ -25,12 +25,40 @@ module Opal
     class ArgsNode < Base
       handle :args
 
+      # ruby allows for args with the same name, if the arg starts with a '_', like:
+      #   def funny_method_name(_, _)
+      #     puts _
+      #   end
+      # but javascript in strict mode does not allow for args with the same name
+      # ruby assigns the value of the first arg given
+      #   funny_method_name(1, 2) => 1
+      # 1. check for args starting with '_' and check if they appear multiple times
+      # 2. leave the first appearance as it is and rename the other ones
+      # compiler result:
+      #   function $$funny_method_name(_, __$2)
+
       def compile
+        same_arg_counter = {}
         children.each_with_index do |arg, idx|
+          if multiple_underscore?(arg)
+            same_arg_counter[arg] ||= 0
+            same_arg_counter[arg]  += 1
+            if same_arg_counter[arg] > 1
+              arg = s(arg.type, :"#{arg.children[0]}_$#{same_arg_counter[arg]}")
+            end
+          end
+
           push ', ' if idx != 0
           push process(arg)
         end
       end
+
+      def multiple_underscore?(arg)
+        arg.type == :arg &&
+          arg.children.count == 1 &&
+          arg.children.first.to_s.start_with?('_') &&
+          children.count(arg) > 1
+      end
     end
   end
 end

data/lib/opal/nodes/base.rb

@@ -29,7 +29,7 @@ module Opal
         false
       end
 
-      attr_reader :compiler, :type
+      attr_reader :compiler, :type, :sexp
 
       def initialize(sexp, level, compiler)
         @sexp = sexp
@@ -73,8 +73,8 @@ module Opal
         push post
       end
 
-      def fragment(str)
-        Opal::Fragment.new str, scope, @sexp
+      def fragment(str, loc: true)
+        Opal::Fragment.new str, scope, loc && @sexp
       end
 
       def error(msg)
@@ -85,8 +85,12 @@ module Opal
         @compiler.scope
       end
 
-      def s(*args)
-        @compiler.s(*args)
+      def top_scope
+        scope.top_scope
+      end
+
+      def s(type, *children)
+        ::Opal::AST::Node.new(type, children, location: @sexp.loc)
       end
 
       def expr?
@@ -165,6 +169,18 @@ module Opal
         scope.in_ensure?
       end
 
+      def in_resbody(&block)
+        scope.in_resbody(&block)
+      end
+
+      def in_resbody?
+        scope.in_resbody?
+      end
+
+      def in_rescue(node, &block)
+        scope.in_rescue(node, &block)
+      end
+
       def class_variable_owner_nesting_level
         cvar_scope = scope
         nesting_level = 0
@@ -192,6 +208,14 @@ module Opal
       def comments
         compiler.comments[@sexp.loc]
       end
+
+      def source_location
+        file = @sexp.loc.expression.source_buffer.name
+        file = "<internal:#{file}>" if file.start_with?("corelib/")
+        file = "<js:#{file}>" if file.end_with?(".js")
+        line = @sexp.loc.line
+        "['#{file}', #{line}]"
+      end
     end
   end
 end