opal 1.7.4 → 1.8.0.beta1

data/opal/corelib/runtime.js

@@ -119,14 +119,16 @@
 
   // @private
   // Pops an exception from the stack and updates `$!`.
-  Opal.pop_exception = function() {
+  Opal.pop_exception = function(rescued_exception) {
     var exception = Opal.exceptions.pop();
-    if (exception) {
+    if (exception === rescued_exception) {
+      // Current $! is raised in the rescue block, so we don't update it
+    }
+    else if (exception) {
       $gvars["!"] = exception;
-      $gvars["@"] = exception.$backtrace();
     }
     else {
-      $gvars["!"] = $gvars["@"] = nil;
+      $gvars["!"] = nil;
     }
   };
 
@@ -152,6 +154,14 @@
     }
   }
 
+  // Reuse the same object for performance/memory sake
+  var prop_options = {
+    value: undefined,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  };
+
   function $prop(object, name, initialValue) {
     if (typeof(object) === "string") {
       // Special case for:
@@ -163,12 +173,8 @@
       // numbers, true, false and null do not support it.
       object[name] = initialValue;
     } else {
-      Object.defineProperty(object, name, {
-        value: initialValue,
-        enumerable: false,
-        configurable: true,
-        writable: true
-      });
+      prop_options.value = initialValue;
+      Object.defineProperty(object, name, prop_options);
     }
   }
 
@@ -538,6 +544,13 @@
   Opal.$$$ = Opal.const_get_qualified;
   Opal.$r = Opal.const_get_relative_factory;
 
+  function descends_from_bridged_class(klass) {
+    if (klass == null) return false;
+    if (klass.$$bridge) return klass;
+    if (klass.$$super) return descends_from_bridged_class(klass.$$super);
+    return false;
+  }
+
   // Modules & Classes
   // -----------------
 
@@ -567,14 +580,13 @@
   // @return new [Class]  or existing ruby class
   //
   function $allocate_class(name, superclass, singleton) {
-    var klass;
+    var klass, bridged_descendant;
 
-    if (superclass != null && superclass.$$bridge) {
+    if (bridged_descendant = descends_from_bridged_class(superclass)) {
       // Inheritance from bridged classes requires
       // calling original JS constructors
       klass = function() {
-        var args = $slice(arguments),
-            self = new ($bind.apply(superclass.$$constructor, [null].concat(args)))();
+        var self = new ($bind.apply(bridged_descendant.$$constructor, $prepend(null, arguments)))();
 
         // and replacing a __proto__ manually
         $set_proto(self, klass.$$prototype);
@@ -601,6 +613,7 @@
     $prop(klass, '$$ancestors', []);
     $prop(klass, '$$ancestors_cache_version', null);
     $prop(klass, '$$subclasses', []);
+    $prop(klass, '$$cloned_from', []);
 
     $prop(klass.$$prototype, '$$class', klass);
 
@@ -768,6 +781,7 @@
     $prop(module, '$$own_prepended_modules', []);
     $prop(module, '$$ancestors', [module]);
     $prop(module, '$$ancestors_cache_version', null);
+    $prop(module, '$$cloned_from', []);
 
     $set_proto(module, Opal.Module.prototype);
 
@@ -1538,7 +1552,6 @@
   // @param method_name [String] The js-name of the method to stub (e.g. "$foo")
   // @return [undefined]
   Opal.stub_for = function(method_name) {
-
     function method_missing_stub() {
       // Copy any given block onto the method_missing dispatcher
       this.$method_missing.$$p = method_missing_stub.$$p;
@@ -1547,11 +1560,8 @@
       method_missing_stub.$$p = null;
 
       // call method missing with correct args (remove '$' prefix on method name)
-      var args_ary = new Array(arguments.length);
-      for(var i = 0, l = args_ary.length; i < l; i++) { args_ary[i] = arguments[i]; }
-
-      return this.$method_missing.apply(this, [method_name.slice(1)].concat(args_ary));
-    }
+      return this.$method_missing.apply(this, $prepend(method_name.slice(1), arguments));
+    };
 
     method_missing_stub.$$stub = true;
 
@@ -1604,15 +1614,22 @@
 
   // Super dispatcher
   Opal.find_super = function(obj, mid, current_func, defcheck, allow_stubs) {
-    var jsid = $jsid(mid), ancestors, super_method;
+    var jsid = $jsid(mid), ancestors, ancestor, super_method, method_owner, current_index = -1, i;
 
     ancestors = get_ancestors(obj);
+    method_owner = current_func.$$owner;
 
-    var current_index = ancestors.indexOf(current_func.$$owner);
+    for (i = 0; i < ancestors.length; i++) {
+      ancestor = ancestors[i];
+      if (ancestor === method_owner || ancestor.$$cloned_from.indexOf(method_owner) !== -1) {
+        current_index = i;
+        break;
+      }
+    }
 
-    for (var i = current_index + 1; i < ancestors.length; i++) {
-      var ancestor = ancestors[i],
-          proto = ancestor.$$prototype;
+    for (i = current_index + 1; i < ancestors.length; i++) {
+      ancestor = ancestors[i];
+      var proto = ancestor.$$prototype;
 
       if (proto.hasOwnProperty('$$dummy')) {
         proto = proto.$$define_methods_on;
@@ -1660,6 +1677,17 @@
   // @deprecated
   Opal.find_iter_super_dispatcher = Opal.find_block_super;
 
+  function call_lambda(block, arg, ret) {
+    try {
+      block(arg);
+    } catch (e) {
+      if (e === ret) {
+        return ret.$v;
+      }
+      throw e;
+    }
+  }
+
   // handles yield calls for 1 yielded arg
   Opal.yield1 = function(block, arg) {
     if (typeof(block) !== "function") {
@@ -1667,16 +1695,23 @@
     }
 
     var has_mlhs = block.$$has_top_level_mlhs_arg,
-        has_trailing_comma = block.$$has_trailing_comma_in_args;
+        has_trailing_comma = block.$$has_trailing_comma_in_args,
+        is_returning_lambda = block.$$is_lambda && block.$$ret;
 
     if (block.length > 1 || ((has_mlhs || has_trailing_comma) && block.length === 1)) {
       arg = Opal.to_ary(arg);
     }
 
     if ((block.length > 1 || (has_trailing_comma && block.length === 1)) && arg.$$is_array) {
+      if (is_returning_lambda) {
+        return call_lambda(block.apply.bind(block, null), arg, block.$$ret);
+      }
       return block.apply(null, arg);
     }
     else {
+      if (is_returning_lambda) {
+        return call_lambda(block, arg, block.$$ret);
+      }
       return block(arg);
     }
   };
@@ -1689,17 +1724,13 @@
 
     if (block.length > 1 && args.length === 1) {
       if (args[0].$$is_array) {
-        return block.apply(null, args[0]);
+        args = args[0];
       }
     }
 
-    if (!args.$$is_array) {
-      var args_ary = new Array(args.length);
-      for(var i = 0, l = args_ary.length; i < l; i++) { args_ary[i] = args[i]; }
-
-      return block.apply(null, args_ary);
+    if (block.$$is_lambda && block.$$ret) {
+      return call_lambda(block.apply.bind(block, null), args, block.$$ret);
     }
-
     return block.apply(null, args);
   };
 
@@ -1812,11 +1843,10 @@
   };
 
   // Used for extracting keyword arguments from arguments passed to
-  // JS function. If provided +arguments+ list doesn't have a Hash
-  // as a last item, returns a blank Hash.
+  // JS function.
   //
   // @param parameters [Array]
-  // @return [Hash]
+  // @return [Hash] or undefined
   //
   Opal.extract_kwargs = function(parameters) {
     var kwargs = parameters[parameters.length - 1];
@@ -1828,7 +1858,7 @@
 
   // Used to get a list of rest keyword arguments. Method takes the given
   // keyword args, i.e. the hash literal passed to the method containing all
-  // keyword arguemnts passed to method, as well as the used args which are
+  // keyword arguments passed to method, as well as the used args which are
   // the names of required and optional arguments defined. This method then
   // just returns all key/value pairs which have not been used, in a new
   // hash literal.
@@ -1838,19 +1868,16 @@
   // @return [Hash]
   //
   Opal.kwrestargs = function(given_args, used_args) {
-    var keys      = [],
-        map       = {},
-        key           ,
-        given_map = given_args.$$smap;
+    var map = new Map();
 
-    for (key in given_map) {
+    Opal.hash_each(given_args, false, function(key, value) {
       if (!used_args[key]) {
-        keys.push(key);
-        map[key] = given_map[key];
+        Opal.hash_put(map, key, value);
       }
-    }
+      return [false, false];
+    });
 
-    return Opal.hash2(keys, map);
+    return map;
   };
 
   function apply_blockopts(block, blockopts) {
@@ -1874,6 +1901,11 @@
   }
   Opal.jsid = $jsid;
 
+  function $prepend(first, second) {
+    if (!second.$$is_array) second = $slice(second);
+    return [first].concat(second);
+  }
+
   // Calls passed method on a ruby object with arguments and block:
   //
   // Can take a method or a method name.
@@ -1917,7 +1949,7 @@
   Opal.send2 = function(recv, body, method, args, block, blockopts) {
     if (body == null && method != null && recv.$method_missing) {
       body = recv.$method_missing;
-      args = [method].concat(args);
+      args = $prepend(method, args);
     }
 
     apply_blockopts(block, blockopts);
@@ -2073,6 +2105,18 @@
     return Opal.defn(Opal.get_singleton_class(obj), jsid, body);
   };
 
+  // Since JavaScript has no concept of modules, we create proxy classes
+  // called `iclasses` that store copies of methods loaded. We need to
+  // update them if we remove a method.
+  function remove_method_from_iclasses(obj, jsid) {
+    if (obj.$$is_module) {
+      for (var i = 0, iclasses = obj.$$iclasses, length = iclasses.length; i < length; i++) {
+        var iclass = iclasses[i];
+        delete iclass[jsid];
+      }
+    }
+  }
+
   // Called from #remove_method.
   Opal.rdef = function(obj, jsid) {
     if (!$has_own(obj.$$prototype, jsid)) {
@@ -2081,6 +2125,8 @@
 
     delete obj.$$prototype[jsid];
 
+    remove_method_from_iclasses(obj, jsid);
+
     if (obj.$$is_singleton) {
       if (obj.$$prototype.$singleton_method_removed && !obj.$$prototype.$singleton_method_removed.$$stub) {
         obj.$$prototype.$singleton_method_removed(jsid.substr(1));
@@ -2101,6 +2147,8 @@
 
     Opal.add_stub_for(obj.$$prototype, jsid);
 
+    remove_method_from_iclasses(obj, jsid);
+
     if (obj.$$is_singleton) {
       if (obj.$$prototype.$singleton_method_undefined && !obj.$$prototype.$singleton_method_undefined.$$stub) {
         obj.$$prototype.$singleton_method_undefined(jsid.substr(1));
@@ -2159,17 +2207,25 @@
 
     // We need a wrapper because otherwise properties
     // would be overwritten on the original body.
-    alias = function() {
-      var block = alias.$$p, args, i, ii;
+    alias = Opal.wrapMethodBody(body);
 
-      args = new Array(arguments.length);
-      for(i = 0, ii = arguments.length; i < ii; i++) {
-        args[i] = arguments[i];
-      }
+    // Try to make the browser pick the right name
+    alias.displayName  = name;
+    alias.$$alias_of   = body;
+    alias.$$alias_name = name;
 
-      alias.$$p = null;
+    Opal.defn(obj, id, alias);
 
-      return Opal.send(this, body, args, block);
+    return obj;
+  };
+
+  Opal.wrapMethodBody = function(body) {
+    var wrapped = function() {
+      var block = wrapped.$$p;
+
+      wrapped.$$p = null;
+
+      return Opal.send(this, body, arguments, block);
     };
 
     // Assign the 'length' value with defineProperty because
@@ -2177,21 +2233,14 @@
     // It doesn't work in older browsers (like Chrome 38), where
     // an exception is thrown breaking Opal altogether.
     try {
-      Object.defineProperty(alias, 'length', { value: body.length });
+      Object.defineProperty(wrapped, 'length', { value: body.length });
     } catch (e) {}
 
-    // Try to make the browser pick the right name
-    alias.displayName       = name;
-
-    alias.$$arity           = body.$$arity == null ? body.length : body.$$arity;
-    alias.$$parameters      = body.$$parameters;
-    alias.$$source_location = body.$$source_location;
-    alias.$$alias_of        = body;
-    alias.$$alias_name      = name;
-
-    Opal.defn(obj, id, alias);
+    wrapped.$$arity           = body.$$arity == null ? body.length : body.$$arity;
+    wrapped.$$parameters      = body.$$parameters;
+    wrapped.$$source_location = body.$$source_location;
 
-    return obj;
+    return wrapped;
   };
 
   Opal.alias_gvar = function(new_name, old_name) {
@@ -2225,228 +2274,169 @@
   // Hashes
   // ------
 
-  Opal.hash_init = function(hash) {
-    hash.$$smap = Object.create(null);
-    hash.$$map  = Object.create(null);
-    hash.$$keys = [];
-  };
+  Opal.hash_init = function (_hash) {
+    console.warn("DEPRECATION: Opal.hash_init is deprecated and is now a no-op.");
+  }
 
   Opal.hash_clone = function(from_hash, to_hash) {
     to_hash.$$none = from_hash.$$none;
     to_hash.$$proc = from_hash.$$proc;
 
-    for (var i = 0, keys = from_hash.$$keys, smap = from_hash.$$smap, len = keys.length, key, value; i < len; i++) {
-      key = keys[i];
-
-      if (key.$$is_string) {
-        value = smap[key];
-      } else {
-        value = key.value;
-        key = key.key;
-      }
-
+    return Opal.hash_each(from_hash, to_hash, function(key, value) {
       Opal.hash_put(to_hash, key, value);
-    }
+      return [false, to_hash];
+    });
   };
 
   Opal.hash_put = function(hash, key, value) {
-    if (key.$$is_string) {
-      if (!$has_own(hash.$$smap, key)) {
-        hash.$$keys.push(key);
-      }
-      hash.$$smap[key] = value;
-      return;
-    }
+    var type = typeof key;
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      hash.set(key, value)
+    } else if (key.$$is_string) {
+      hash.set(key.valueOf(), value);
+    } else {
+      if (!hash.$$keys)
+        hash.$$keys = new Map();
 
-    var key_hash, bucket, last_bucket;
-    key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          keys = hash.$$keys;
 
-    if (!$has_own(hash.$$map, key_hash)) {
-      bucket = {key: key, key_hash: key_hash, value: value};
-      hash.$$keys.push(bucket);
-      hash.$$map[key_hash] = bucket;
-      return;
-    }
+      if (!keys.has(key_hash)) {
+        keys.set(key_hash, [key]);
+        hash.set(key, value);
+        return;
+      }
 
-    bucket = hash.$$map[key_hash];
+      var objects = keys.get(key_hash),
+          object;
 
-    while (bucket) {
-      if (key === bucket.key || key['$eql?'](bucket.key)) {
-        last_bucket = undefined;
-        bucket.value = value;
-        break;
+      for (var i=0; i<objects.length; i++) {
+        object = objects[i];
+        if (key === object || key['$eql?'](object)) {
+          hash.set(object, value);
+          return;
+        }
       }
-      last_bucket = bucket;
-      bucket = bucket.next;
-    }
 
-    if (last_bucket) {
-      bucket = {key: key, key_hash: key_hash, value: value};
-      hash.$$keys.push(bucket);
-      last_bucket.next = bucket;
+      objects.push(key);
+      hash.set(key, value);
     }
   };
 
   Opal.hash_get = function(hash, key) {
-    if (key.$$is_string) {
-      if ($has_own(hash.$$smap, key)) {
-        return hash.$$smap[key];
-      }
-      return;
-    }
-
-    var key_hash, bucket;
-    key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
-
-    if ($has_own(hash.$$map, key_hash)) {
-      bucket = hash.$$map[key_hash];
-
-      while (bucket) {
-        if (key === bucket.key || key['$eql?'](bucket.key)) {
-          return bucket.value;
+    var type = typeof key;
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      return hash.get(key)
+    } else if (hash.$$keys) {
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          objects = hash.$$keys.get(key_hash),
+          object;
+
+      if (objects !== undefined) {
+        for (var i=0; i<objects.length; i++) {
+          object = objects[i];
+          if (key === object || key['$eql?'](object))
+            return hash.get(object);
         }
-        bucket = bucket.next;
+      } else if (key.$$is_string) {
+        return hash.get(key_hash);
       }
+    } else if (key.$$is_string) {
+      return hash.get(key.valueOf());
     }
   };
 
-  Opal.hash_delete = function(hash, key) {
-    var i, keys = hash.$$keys, length = keys.length, value, key_tmp;
-
-    if (key.$$is_string) {
-      if (typeof key !== "string") key = key.valueOf();
-
-      if (!$has_own(hash.$$smap, key)) {
-        return;
-      }
-
-      for (i = 0; i < length; i++) {
-        key_tmp = keys[i];
-
-        if (key_tmp.$$is_string && typeof key_tmp !== "string") {
-          key_tmp = key_tmp.valueOf();
-        }
-
-        if (key_tmp === key) {
-          keys.splice(i, 1);
-          break;
-        }
-      }
-
-      value = hash.$$smap[key];
-      delete hash.$$smap[key];
+  function $hash_delete_stage2(hash, key) {
+    var value = hash.get(key);
+    if (value !== undefined) {
+      hash.delete(key);
       return value;
     }
+  }
 
-    var key_hash = key.$hash();
-
-    if (!$has_own(hash.$$map, key_hash)) {
-      return;
-    }
-
-    var bucket = hash.$$map[key_hash], last_bucket;
-
-    while (bucket) {
-      if (key === bucket.key || key['$eql?'](bucket.key)) {
-        value = bucket.value;
-
-        for (i = 0; i < length; i++) {
-          if (keys[i] === bucket) {
-            keys.splice(i, 1);
-            break;
+  Opal.hash_delete = function(hash, key) {
+    var type = typeof key
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      return $hash_delete_stage2(hash, key);
+    } else if (hash.$$keys) {
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          objects = hash.$$keys.get(key_hash),
+          object;
+
+      if (objects !== undefined) {
+        for (var i=0; i<objects.length; i++) {
+          object = objects[i];
+          if (key === object || key['$eql?'](object)) {
+            objects.splice(i, 1);
+            if (objects.length === 0)
+              hash.$$keys.delete(key_hash);
+            return $hash_delete_stage2(hash, object);
           }
         }
-
-        if (last_bucket && bucket.next) {
-          last_bucket.next = bucket.next;
-        }
-        else if (last_bucket) {
-          delete last_bucket.next;
-        }
-        else if (bucket.next) {
-          hash.$$map[key_hash] = bucket.next;
-        }
-        else {
-          delete hash.$$map[key_hash];
-        }
-
-        return value;
+      } else if (key.$$is_string) {
+        return $hash_delete_stage2(hash, key_hash);
       }
-      last_bucket = bucket;
-      bucket = bucket.next;
+    } else if (key.$$is_string) {
+      return $hash_delete_stage2(hash, key.valueOf());
     }
   };
 
   Opal.hash_rehash = function(hash) {
-    for (var i = 0, length = hash.$$keys.length, key_hash, bucket, last_bucket; i < length; i++) {
+    var keys = hash.$$keys;
 
-      if (hash.$$keys[i].$$is_string) {
-        continue;
-      }
+    if (keys)
+      keys.clear();
 
-      key_hash = hash.$$keys[i].key.$hash();
+    Opal.hash_each(hash, false, function(key, value) {
+      var type = typeof key;
+      if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint")
+        return [false, false]; // nothing to rehash
 
-      if (key_hash === hash.$$keys[i].key_hash) {
-        continue;
-      }
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash());
 
-      bucket = hash.$$map[hash.$$keys[i].key_hash];
-      last_bucket = undefined;
+      if (!keys)
+        hash.$$keys = keys = new Map();
 
-      while (bucket) {
-        if (bucket === hash.$$keys[i]) {
-          if (last_bucket && bucket.next) {
-            last_bucket.next = bucket.next;
-          }
-          else if (last_bucket) {
-            delete last_bucket.next;
-          }
-          else if (bucket.next) {
-            hash.$$map[hash.$$keys[i].key_hash] = bucket.next;
-          }
-          else {
-            delete hash.$$map[hash.$$keys[i].key_hash];
-          }
-          break;
-        }
-        last_bucket = bucket;
-        bucket = bucket.next;
+      if (!keys.has(key_hash)) {
+        keys.set(key_hash, [key]);
+        return [false, false];
       }
 
-      hash.$$keys[i].key_hash = key_hash;
+      var objects = keys.get(key_hash),
+          objects_copy = $slice(objects),
+          object;
 
-      if (!$has_own(hash.$$map, key_hash)) {
-        hash.$$map[key_hash] = hash.$$keys[i];
-        continue;
+      for (var i=0; i<objects_copy.length; i++) {
+        object = objects_copy[i];
+        if (key === object || key['$eql?'](object)) {
+          // got a duplicate, remove it
+          objects.splice(objects.indexOf(object), 1);
+          hash.delete(object);
+        }
       }
 
-      bucket = hash.$$map[key_hash];
-      last_bucket = undefined;
+      objects.push(key);
 
-      while (bucket) {
-        if (bucket === hash.$$keys[i]) {
-          last_bucket = undefined;
-          break;
-        }
-        last_bucket = bucket;
-        bucket = bucket.next;
-      }
+      return [false, false]
+    });
 
-      if (last_bucket) {
-        last_bucket.next = hash.$$keys[i];
-      }
-    }
+    return hash;
   };
 
-  Opal.hash = function() {
-    var arguments_length = arguments.length, args, hash, i, length, key, value;
+  Opal.hash = function () {
+    var arguments_length = arguments.length,
+      args,
+      hash,
+      i,
+      length,
+      key,
+      value;
 
     if (arguments_length === 1 && arguments[0].$$is_hash) {
       return arguments[0];
     }
 
-    hash = new Opal.Hash();
-    Opal.hash_init(hash);
+    hash = new Map();
 
     if (arguments_length === 1) {
       args = arguments[0];
@@ -2456,7 +2446,7 @@
 
         for (i = 0; i < length; i++) {
           if (args[i].length !== 2) {
-            $raise(Opal.ArgumentError, "value not of length 2: " + args[i].$inspect());
+            $raise(Opal.ArgumentError, 'value not of length 2: ' + args[i].$inspect());
           }
 
           key = args[i][0];
@@ -2466,8 +2456,7 @@
         }
 
         return hash;
-      }
-      else {
+      } else {
         args = arguments[0];
         for (key in args) {
           if ($has_own(args, key)) {
@@ -2482,7 +2471,7 @@
     }
 
     if (arguments_length % 2 !== 0) {
-      $raise(Opal.ArgumentError, "odd number of arguments for Hash");
+      $raise(Opal.ArgumentError, 'odd number of arguments for Hash');
     }
 
     for (i = 0; i < arguments_length; i += 2) {
@@ -2501,15 +2490,29 @@
   // function.
   //
   Opal.hash2 = function(keys, smap) {
-    var hash = new Opal.Hash();
-
-    hash.$$smap = smap;
-    hash.$$map  = Object.create(null);
-    hash.$$keys = keys;
+    console.warn("DEPRECATION: `Opal.hash2` is deprecated and will be removed in Opal 2.0. Use `new Map()` with an array of key/value pairs instead.");
 
+    var hash = new Map();
+    for (var i = 0, max = keys.length; i < max; i++) {
+      hash.set(keys[i], smap[keys[i]]);
+    }
     return hash;
   };
 
+  Opal.hash_each = function (hash, dres, fun) {
+    // dres = default result, returned if hash is empty
+    // fun is called as fun(key, value) and must return a array with [break, result]
+    // if break is true, iteration stops and result is returned
+    // if break is false, iteration continues and eventually the last result is returned
+    var res;
+    for (var i = 0, entry, entries = Array.from(hash.entries()), l = entries.length; i < l; i++) {
+      entry = entries[i];
+      res = fun(entry[0], entry[1]);
+      if (res[0]) return res[1];
+    }
+    return res ? res[1] : dres;
+  };
+
   // Create a new range instance with first and last values, and whether the
   // range excludes the last value.
   //
@@ -2547,7 +2550,7 @@
   // helper that can be used from methods
   function $deny_frozen_access(obj) {
     if (obj.$$frozen) {
-      $raise(Opal.FrozenError, "can't modify frozen " + (obj.$class()) + ": " + (obj), Opal.hash2(["receiver"], {"receiver": obj}));
+      $raise(Opal.FrozenError, "can't modify frozen " + (obj.$class()) + ": " + (obj), new Map([["receiver", obj]]));
     }
   };
   Opal.deny_frozen_access = $deny_frozen_access;
@@ -2672,7 +2675,7 @@
         if (part.ignoreCase !== ignoreCase)
           Opal.Kernel.$warn(
             "ignore case doesn't match for " + part.source.$inspect(),
-            Opal.hash({uplevel: 1})
+            new Map([['uplevel',  1]])
           )
 
         part = part.source;
@@ -2923,7 +2926,7 @@
   // Primitives for handling parameters
   Opal.ensure_kwargs = function(kwargs) {
     if (kwargs == null) {
-      return Opal.hash2([], {});
+      return new Map();
     } else if (kwargs.$$is_hash) {
       return kwargs;
     } else {
@@ -2932,10 +2935,11 @@
   }
 
   Opal.get_kwarg = function(kwargs, key) {
-    if (!$has_own(kwargs.$$smap, key)) {
+    var kwarg = Opal.hash_get(kwargs, key);
+    if (kwarg === undefined) {
       $raise(Opal.ArgumentError, 'missing keyword: '+key);
     }
-    return kwargs.$$smap[key];
+    return kwarg;
   }
 
   // Arrays of size > 32 elements that contain only strings,
@@ -2965,6 +2969,20 @@
     return array;
   }
 
+  // Opal32-checksum algorithm for #hash
+  // -----------------------------------
+  Opal.opal32_init = $return_val(0x4f70616c);
+
+  function $opal32_ror(n, d) {
+    return (n << d)|(n >>> (32 - d));
+  };
+
+  Opal.opal32_add = function(hash, next) {
+    hash ^= next;
+    hash = $opal32_ror(hash, 1);
+    return hash;
+  };
+
   // Initialization
   // --------------
   Opal.BasicObject = BasicObject = $allocate_class('BasicObject', null);
@@ -3020,10 +3038,9 @@
 
   // Foward calls to define_method on the top object to Object
   function top_define_method() {
-    var args = $slice(arguments);
     var block = top_define_method.$$p;
     top_define_method.$$p = null;
-    return Opal.send(_Object, 'define_method', args, block)
+    return Opal.send(_Object, 'define_method', arguments, block)
   };
 
   // Nil
@@ -3037,16 +3054,37 @@
   Object.seal(nil);
 
   Opal.thrower = function(type) {
-    var thrower = new Error('unexpected '+type);
-    thrower.$thrower_type = type;
-    thrower.$throw = function(value) {
-      if (value == null) value = nil;
-      thrower.$v = value;
-      throw thrower;
-    };
+    var thrower = {
+      $thrower_type: type,
+      $throw: function(value, called_from_lambda) {
+        if (value == null) value = nil;
+        if (this.is_orphan && !called_from_lambda) {
+          $raise(Opal.LocalJumpError, 'unexpected ' + type, value, type.$to_sym());
+        }
+        this.$v = value;
+        throw this;
+      },
+      is_orphan: false
+    }
     return thrower;
   };
 
+  // Define a "$@" global variable, which would compute and return a backtrace on demand.
+  Object.defineProperty($gvars, "@", {
+    enumerable: true,
+    configurable: true,
+    get: function() {
+      if ($truthy($gvars["!"])) return $gvars["!"].$backtrace();
+      return nil;
+    },
+    set: function(bt) {
+      if ($truthy($gvars["!"]))
+        $gvars["!"].$set_backtrace(bt);
+      else
+        $raise(Opal.ArgumentError, "$! not set");
+    }
+  });
+
   Opal.t_eval_return = Opal.thrower("return");
 
   TypeError.$$super = Error;