opal 0.7.0.beta1 → 0.7.0.beta2

data/opal/corelib/enumerator.rb

@@ -59,7 +59,7 @@ class Enumerator
     return enum_for :with_index, offset unless block
 
     %x{
-      var result
+      var result, index = 0;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)},
@@ -78,13 +78,15 @@ class Enumerator
       if (result !== undefined) {
         return result;
       }
+
+      return nil;
     }
   end
 
   alias with_object each_with_object
 
   def inspect
-    result = "#<#{self.class.name}: #{@object.inspect}:#{@method}"
+    result = "#<#{self.class}: #{@object.inspect}:#{@method}"
 
     unless @args.empty?
       result += "(#{@args.inspect[Range.new(1, -2)]})"
@@ -109,7 +111,7 @@ class Enumerator
         try {
           args.unshift(#{yielder});
 
-          if ($opal.$yieldX(#@block, args) === $breaker) {
+          if (Opal.yieldX(#@block, args) === $breaker) {
             return $breaker.$v;
           }
         }
@@ -134,7 +136,7 @@ class Enumerator
 
     def yield(*values)
       %x{
-        var value = $opal.$yieldX(#@block, values);
+        var value = Opal.yieldX(#@block, values);
 
         if (value === $breaker) {
           throw $breaker;
@@ -167,7 +169,7 @@ class Enumerator
             %x{
               args.unshift(#{yielder});
 
-              if ($opal.$yieldX(block, args) === $breaker) {
+              if (Opal.yieldX(block, args) === $breaker) {
                 return $breaker;
               }
             }
@@ -191,7 +193,7 @@ class Enumerator
 
       Lazy.new(self, enumerator_size) {|enum, *args|
         %x{
-          var value = $opal.$yieldX(block, args);
+          var value = Opal.yieldX(block, args);
 
           if (value === $breaker) {
             return $breaker;
@@ -209,7 +211,7 @@ class Enumerator
 
       Lazy.new(self, nil) {|enum, *args|
         %x{
-          var value = $opal.$yieldX(block, args);
+          var value = Opal.yieldX(block, args);
 
           if (value === $breaker) {
             return $breaker;
@@ -265,7 +267,7 @@ class Enumerator
       Lazy.new(self, nil) {|enum, *args|
         if succeeding
           %x{
-            var value = $opal.$yieldX(block, args);
+            var value = Opal.yieldX(block, args);
 
             if (value === $breaker) {
               return $breaker;
@@ -294,7 +296,7 @@ class Enumerator
 
       Lazy.new(self, nil) {|enum, *args|
         %x{
-          var value = $opal.$yieldX(block, args);
+          var value = Opal.yieldX(block, args);
 
           if (value === $breaker) {
             return $breaker;
@@ -317,13 +319,13 @@ class Enumerator
                 value = #{pattern === `param`};
 
             if (#{Opal.truthy?(`value`)}) {
-              value = $opal.$yield1(block, param);
+              value = Opal.yield1(block, param);
 
               if (value === $breaker) {
                 return $breaker;
               }
 
-              #{enum.yield `$opal.$yield1(block, param)`};
+              #{enum.yield `Opal.yield1(block, param)`};
             }
           }
         }
@@ -352,7 +354,7 @@ class Enumerator
 
       Lazy.new(self, nil) {|enum, *args|
         %x{
-          var value = $opal.$yieldX(block, args);
+          var value = Opal.yieldX(block, args);
 
           if (value === $breaker) {
             return $breaker;
@@ -397,7 +399,7 @@ class Enumerator
 
       Lazy.new(self, nil) {|enum, *args|
         %x{
-          var value = $opal.$yieldX(block, args);
+          var value = Opal.yieldX(block, args);
 
           if (value === $breaker) {
             return $breaker;
@@ -416,7 +418,7 @@ class Enumerator
     alias to_enum enum_for
 
     def inspect
-      "#<#{self.class.name}: #{@enumerator.inspect}>"
+      "#<#{self.class}: #{@enumerator.inspect}>"
     end
   end
 end

data/opal/corelib/error.rb

@@ -1,15 +1,24 @@
 class Exception
   attr_reader :message
 
-  def self.new(message = '')
+  def self.new(message = 'Exception')
     %x{
-      var err = new Error(message);
-      err.$$class = self;
+      var err = new self.$$alloc(message);
+
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(err);
+      }
+
       err.name = self.$$name;
+      err.$initialize(message);
       return err;
     }
   end
 
+  def initialize(message)
+    `self.message = message`
+  end
+
   def backtrace
     %x{
       var backtrace = self.stack;
@@ -26,7 +35,7 @@ class Exception
   end
 
   def inspect
-    "#<#{self.class.name}: '#@message'>"
+    "#<#{self.class}: '#@message'>"
   end
 
   alias to_s message

data/opal/corelib/hash.rb

@@ -4,7 +4,7 @@ class Hash
   include Enumerable
 
   def self.[](*objs)
-    `$opal.hash.apply(null, objs)`
+    `Opal.hash.apply(null, objs)`
   end
 
   def self.allocate
@@ -12,6 +12,7 @@ class Hash
       var hash = new self.$$alloc;
 
       hash.map  = {};
+      hash.smap = {};
       hash.keys = [];
       hash.none = nil;
       hash.proc = nil;
@@ -34,7 +35,7 @@ class Hash
         return true;
       }
 
-      if (!other.map || !other.keys) {
+      if (!other.keys || !other.smap || !other.map) {
         return false;
       }
 
@@ -42,12 +43,30 @@ class Hash
         return false;
       }
 
-      var map  = self.map,
-          map2 = other.map;
+      var _map  = self.map,
+          smap  = self.smap,
+          _map2 = other.map,
+          smap2 = other.smap,
+          map, map2, key, khash, value, value2;
 
       for (var i = 0, length = self.keys.length; i < length; i++) {
-        var key = self.keys[i], obj = map[key], obj2 = map2[key];
-        if (obj2 === undefined || #{`obj` != `obj2`}) {
+        key = self.keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map   = smap;
+          map2  = smap2;
+        } else {
+          khash = key.$hash();
+          map   = _map;
+          map2  = _map2;
+        }
+
+        value  = map[khash];
+        if (value === undefined) console.log('==', key, self);
+        value2 = map2[khash];
+
+        if (value2 === undefined || #{not(`value` == `value2`)}) {
           return false;
         }
       }
@@ -58,10 +77,21 @@ class Hash
 
   def [](key)
     %x{
-      var map = self.map;
+      var map, khash;
+
+      if (key.$$is_string) {
+        map = self.smap;
+        khash = key;
+      } else {
+        map = self.map;
+        khash = key.$hash();
+      }
 
-      if ($opal.hasOwnProperty.call(map, key)) {
-        return map[key];
+      if (map === undefined) { console.log(self, '[] --> key:', key, khash, map) }
+
+
+      if (Opal.hasOwnProperty.call(map, khash)) {
+        return map[khash];
       }
 
       var proc = #@proc;
@@ -76,13 +106,21 @@ class Hash
 
   def []=(key, value)
     %x{
-      var map = self.map;
+      var map, khash, value;
+
+      if (key.$$is_string) {
+        map = self.smap;
+        khash = key;
+      } else {
+        map = self.map;
+        khash = key.$hash();
+      }
 
-      if (!$opal.hasOwnProperty.call(map, key)) {
+      if (!Opal.hasOwnProperty.call(map, khash)) {
         self.keys.push(key);
       }
 
-      map[key] = value;
+      map[khash] = value;
 
       return value;
     }
@@ -90,13 +128,22 @@ class Hash
 
   def assoc(object)
     %x{
-      var keys = self.keys, key;
+      var keys = self.keys,
+          map, key, khash;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
 
         if (#{`key` == object}) {
-          return [key, self.map[key]];
+          if (key.$$is_string) {
+            map = self.smap;
+            khash = key;
+          } else {
+            map = self.map;
+            khash = key.$hash();
+          }
+
+          return [key, map[khash]];
         }
       }
 
@@ -107,6 +154,7 @@ class Hash
   def clear
     %x{
       self.map = {};
+      self.smap = {};
       self.keys = [];
       return self;
     }
@@ -114,25 +162,41 @@ class Hash
 
   def clone
     %x{
-      var map  = {},
-          keys = [];
+      var _map  = {},
+          smap  = {},
+          _map2 = self.map,
+          smap2 = self.smap,
+          keys  = [],
+          map, map2, key, khash, value;
 
       for (var i = 0, length = self.keys.length; i < length; i++) {
-        var key   = self.keys[i],
-            value = self.map[key];
+        key   = self.keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+          map2 = smap2;
+        } else {
+          khash = key.$hash();
+          map = _map;
+          map2 = _map2;
+        }
+
+        value = map2[khash];
 
         keys.push(key);
-        map[key] = value;
+        map[khash] = value;
       }
 
-      var hash = new self.$$class.$$alloc();
+      var clone = new self.$$class.$$alloc();
 
-      hash.map  = map;
-      hash.keys = keys;
-      hash.none = self.none;
-      hash.proc = self.proc;
+      clone.map  = _map;
+      clone.smap = smap;
+      clone.keys = keys;
+      clone.none = self.none;
+      clone.proc = self.proc;
 
-      return hash;
+      return clone;
     }
   end
 
@@ -172,10 +236,20 @@ class Hash
 
   def delete(key, &block)
     %x{
-      var map  = self.map, result = map[key];
+      var result, map, khash;
+
+      if (key.$$is_string) {
+        map = self.smap;
+        khash = key;
+      } else {
+        map = self.map;
+        khash = key.$hash();
+      }
+
+      result = map[khash];
 
       if (result != null) {
-        delete map[key];
+        delete map[khash];
         self.keys.$delete(key);
 
         return result;
@@ -192,18 +266,31 @@ class Hash
     return enum_for :delete_if unless block
 
     %x{
-      var map = self.map, keys = self.keys, value;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          map, key, value, obj, khash;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        key = keys[i];
 
-        if ((value = block(key, obj)) === $breaker) {
+        if (key.$$is_string) {
+          map = smap;
+          khash = key;
+        } else {
+          map = _map;
+          khash = key.$hash();
+        }
+        obj = map[khash];
+        value = block(key, obj);
+
+        if (value === $breaker) {
           return $breaker.$v;
         }
 
         if (value !== false && value !== nil) {
           keys.splice(i, 1);
-          delete map[key];
+          delete map[khash];
 
           length--;
           i--;
@@ -220,12 +307,23 @@ class Hash
     return enum_for :each unless block
 
     %x{
-      var map  = self.map,
-          keys = self.keys;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          map, key, khash, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key   = keys[i],
-            value = $opal.$yield1(block, [key, map[key]]);
+        key = keys[i];
+
+        if (key.$$is_string) {
+          map = smap;
+          khash = key;
+        } else {
+          map = _map;
+          khash = key.$hash();
+        }
+
+        value = Opal.yield1(block, [key, map[khash]]);
 
         if (value === $breaker) {
           return $breaker.$v;
@@ -238,12 +336,12 @@ class Hash
 
   def each_key(&block)
     return enum_for :each_key unless block
-
+    # @keys.each(&block)
     %x{
-      var keys = self.keys;
+      var keys = self.keys, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
+        key = keys[i];
 
         if (block(key) === $breaker) {
           return $breaker.$v;
@@ -260,10 +358,22 @@ class Hash
     return enum_for :each_value unless block
 
     %x{
-      var map = self.map, keys = self.keys;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        if (block(map[keys[i]]) === $breaker) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          map = smap;
+          khash = key;
+        } else {
+          map = _map;
+          khash = key.$hash();
+        }
+
+        if (block(map[khash]) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -280,7 +390,17 @@ class Hash
 
   def fetch(key, defaults = undefined, &block)
     %x{
-      var value = self.map[key];
+      var map, khash, value;
+
+      if (key.$$is_string) {
+        khash = key;
+        map = self.smap;
+      } else {
+        khash = key.$hash();
+        map = self.map;
+      }
+
+      value = map[khash];
 
       if (value != null) {
         return value;
@@ -306,10 +426,24 @@ class Hash
 
   def flatten(level=undefined)
     %x{
-      var map = self.map, keys = self.keys, result = [];
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          result = [],
+          map, key, khash, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], value = map[key];
+        key = keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        value = map[khash];
 
         result.push(key);
 
@@ -331,13 +465,34 @@ class Hash
   end
 
   def has_key?(key)
-    `$opal.hasOwnProperty.call(self.map, key)`
+    %x{
+      var keys = self.keys,
+          map, khash;
+
+      if (key.$$is_string) {
+        khash = key;
+        map = self.smap;
+      } else {
+        khash = key.$hash();
+        map = self.map;
+      }
+
+      if (Opal.hasOwnProperty.call(map, khash)) {
+        for (var i = 0, length = keys.length; i < length; i++) {
+          if (!#{not(key.eql?(`keys[i]`))}) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
   end
 
   def has_value?(value)
     %x{
-      for (var assoc in self.map) {
-        if (#{`self.map[assoc]` == value}) {
+      for (var khash in self.map) {
+        if (#{`self.map[khash]` == value}) {
           return true;
         }
       }
@@ -346,20 +501,27 @@ class Hash
     }
   end
 
-  def hash
-    `self.$$id`
-  end
-
   alias include? has_key?
 
   def index(object)
     %x{
-      var map = self.map, keys = self.keys;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          map, khash, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
+        key = keys[i];
+
+        if (key.$$is_string) {
+          map = smap;
+          khash = key;
+        } else {
+          map = _map;
+          khash = key.$hash();
+        }
 
-        if (#{`map[key]` == object}) {
+        if (#{`map[khash]` == object}) {
           return key;
         }
       }
@@ -370,13 +532,26 @@ class Hash
 
   def indexes(*keys)
     %x{
-      var result = [], map = self.map, val;
+      var result = [],
+          _map = self.map,
+          smap = self.smap,
+          map, key, khash, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], val = map[key];
+        key = keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        value = map[khash];
 
-        if (val != null) {
-          result.push(val);
+        if (value != null) {
+          result.push(value);
         }
         else {
           result.push(self.none);
@@ -389,34 +564,80 @@ class Hash
 
   alias indices indexes
 
+  `var inspect_ids = null;`
   def inspect
     %x{
-      var inspect = [], keys = self.keys, map = self.map;
+      var top = (inspect_ids === null);
+      try {
+        var inspect = [],
+            keys = self.keys
+            _map = self.map,
+            smap = self.smap,
+            id = #{object_id};
+
+        if (top) {
+          inspect_ids = {}
+        }
 
-      for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], val = map[key];
+        if (inspect_ids.hasOwnProperty(id)) {
+          return '{...}';
+        }
 
-        if (val === self) {
-          inspect.push(#{`key`.inspect} + '=>' + '{...}');
-        } else {
-          inspect.push(#{`key`.inspect} + '=>' + #{`map[key]`.inspect});
+        inspect_ids[id] = true;
+
+        for (var i = 0, length = keys.length; i < length; i++) {
+          var key = keys[i],
+              value = key.$$is_string ? smap[key] : _map[key.$hash()];
+
+          value = value;
+          key = key;
+          inspect.push(key.$inspect() + '=>' + value.$inspect());
         }
-      }
 
-      return '{' + inspect.join(', ') + '}';
+        return '{' + inspect.join(', ') + '}';
+      } finally {
+
+        if (top) {
+          inspect_ids = null;
+        }
+      }
     }
   end
 
   def invert
     %x{
-      var result = $opal.hash(), keys = self.keys, map = self.map,
-          keys2 = result.keys, map2 = result.map;
+      var result = Opal.hash(),
+          keys = self.keys,
+          _map = self.map,
+          smap = self.smap,
+          keys2 = result.keys,
+          _map2 = result.map,
+          smap2 = result.smap,
+          map, map2, key, khash, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        key = keys[i];
+
+        if (key.$$is_string) {
+          map = smap;
+          khash = key;
+        } else {
+          map = _map;
+          khash = key.$hash();
+        }
+
+        value = map[khash];
+        keys2.push(value);
+
+        if (value.$$is_string) {
+          map2 = smap2;
+          khash = value;
+        } else {
+          map2 = _map2;
+          khash = value.$hash();
+        }
 
-        keys2.push(obj);
-        map2[obj] = key;
+        map2[khash] = key;
       }
 
       return result;
@@ -427,18 +648,32 @@ class Hash
     return enum_for :keep_if unless block
 
     %x{
-      var map = self.map, keys = self.keys, value;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          map, key, khash, value, keep;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        key = keys[i];
 
-        if ((value = block(key, obj)) === $breaker) {
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        value = map[khash];
+        keep  = block(key, value);
+
+        if (keep === $breaker) {
           return $breaker.$v;
         }
 
-        if (value === false || value === nil) {
+        if (keep === false || keep === nil) {
           keys.splice(i, 1);
-          delete map[key];
+          delete map[khash];
 
           length--;
           i--;
@@ -464,50 +699,13 @@ class Hash
   alias member? has_key?
 
   def merge(other, &block)
-    %x{
-      if (! #{Hash === other}) {
-        other = #{Opal.coerce_to!(other, Hash, :to_hash)};
-      }
-
-      var keys = self.keys, map = self.map,
-          result = $opal.hash(), keys2 = result.keys, map2 = result.map;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
-
-        keys2.push(key);
-        map2[key] = map[key];
-      }
-
-      var keys = other.keys, map = other.map;
+    unless Hash === other
+      other = Opal.coerce_to!(other, Hash, :to_hash)
+    end
 
-      if (block === nil) {
-        for (var i = 0, length = keys.length; i < length; i++) {
-          var key = keys[i];
-
-          if (map2[key] == null) {
-            keys2.push(key);
-          }
-
-          map2[key] = map[key];
-        }
-      }
-      else {
-        for (var i = 0, length = keys.length; i < length; i++) {
-          var key = keys[i];
-
-          if (map2[key] == null) {
-            keys2.push(key);
-            map2[key] = map[key];
-          }
-          else {
-            map2[key] = block(key, map2[key], map[key]);
-          }
-        }
-      }
-
-      return result;
-    }
+    cloned = clone
+    cloned.merge!(other, &block)
+    cloned
   end
 
   def merge!(other, &block)
@@ -516,30 +714,58 @@ class Hash
         other = #{Opal.coerce_to!(other, Hash, :to_hash)};
       }
 
-      var keys = self.keys, map = self.map,
-          keys2 = other.keys, map2 = other.map;
+      var keys  = self.keys,
+          _map  = self.map,
+          smap  = self.smap,
+          keys2 = other.keys,
+          _map2 = other.map,
+          smap2 = other.smap,
+          map, map2, key, khash, value, value2;
 
       if (block === nil) {
         for (var i = 0, length = keys2.length; i < length; i++) {
-          var key = keys2[i];
+          key = keys2[i];
+
+          if (key.$$is_string) {
+            khash = key;
+            map = smap;
+            map2 = smap2;
+          } else {
+            khash = key.$hash();
+            map = _map;
+            map2 = _map2;
+          }
 
-          if (map[key] == null) {
+          if (map[khash] == null) {
             keys.push(key);
           }
 
-          map[key] = map2[key];
+          map[khash] = map2[khash];
         }
       }
       else {
         for (var i = 0, length = keys2.length; i < length; i++) {
-          var key = keys2[i];
+          key    = keys2[i];
+
+          if (key.$$is_string) {
+            khash = key;
+            map = smap;
+            map2 = smap2;
+          } else {
+            khash = key.$hash();
+            map = _map;
+            map2 = _map2;
+          }
 
-          if (map[key] == null) {
+          value  = map[khash];
+          value2 = map2[khash];
+
+          if (value == null) {
             keys.push(key);
-            map[key] = map2[key];
+            map[khash] = value2;
           }
           else {
-            map[key] = block(key, map[key], map2[key]);
+            map[khash] = block(key, value, value2);
           }
         }
       }
@@ -550,13 +776,26 @@ class Hash
 
   def rassoc(object)
     %x{
-      var keys = self.keys, map = self.map;
+      var keys = self.keys,
+          _map = self.map,
+          smap = self.smap,
+          key, khash, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        key = keys[i]
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        value = map[khash];
 
-        if (#{`obj` == object}) {
-          return [key, obj];
+        if (#{`value` == object}) {
+          return [key, value];
         }
       }
 
@@ -568,19 +807,37 @@ class Hash
     return enum_for :reject unless block
 
     %x{
-      var keys = self.keys, map = self.map,
-          result = $opal.hash(), map2 = result.map, keys2 = result.keys;
+      var keys   = self.keys,
+          _map    = self.map,
+          smap    = self.smap,
+          result = Opal.hash(),
+          _map2   = result.map,
+          smap2   = result.smap,
+          keys2  = result.keys,
+          map, map2, key, khash, object, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key], value;
+        key = keys[i];
 
-        if ((value = block(key, obj)) === $breaker) {
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+          map2 = smap2;
+        } else {
+          khash = key.$hash();
+          map = _map;
+          map2 = _map2;
+        }
+
+        object = map[khash];
+
+        if ((value = block(key, object)) === $breaker) {
           return $breaker.$v;
         }
 
         if (value === false || value === nil) {
           keys2.push(key);
-          map2[key] = obj;
+          map2[khash] = object;
         }
       }
 
@@ -590,12 +847,28 @@ class Hash
 
   def replace(other)
     %x{
-      var map = self.map = {}, keys = self.keys = [];
+      var keys  = self.keys = [],
+          _map  = self.map  = {},
+          smap  = self.smap = {},
+          _map2 = other.map,
+          smap2 = other.smap,
+          key, khash, map, map2;
 
       for (var i = 0, length = other.keys.length; i < length; i++) {
-        var key = other.keys[i];
+        key = other.keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+          map2 = smap2;
+        } else {
+          khash = key.$hash();
+          map = _map;
+          map2 = _map2;
+        }
+
         keys.push(key);
-        map[key] = other.map[key];
+        map[khash] = map2[khash];
       }
 
       return self;
@@ -606,19 +879,38 @@ class Hash
     return enum_for :select unless block
 
     %x{
-      var keys = self.keys, map = self.map,
-          result = $opal.hash(), map2 = result.map, keys2 = result.keys;
+      var keys   = self.keys,
+          _map   = self.map,
+          smap   = self.smap,
+          result = Opal.hash(),
+          _map2  = result.map,
+          smap2  = result.smap,
+          keys2  = result.keys,
+          map, map2, key, khash, value, object;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key], value;
+        key = keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+          map2 = smap2;
+        } else {
+          khash = key.$hash();
+          map = _map;
+          map2 = _map2;
+        }
+
+        value = map[khash];
+        object = block(key, value);
 
-        if ((value = block(key, obj)) === $breaker) {
+        if (object === $breaker) {
           return $breaker.$v;
         }
 
-        if (value !== false && value !== nil) {
+        if (object !== false && object !== nil) {
           keys2.push(key);
-          map2[key] = obj;
+          map2[khash] = value;
         }
       }
 
@@ -630,18 +922,33 @@ class Hash
     return enum_for :select! unless block
 
     %x{
-      var map = self.map, keys = self.keys, value, result = nil;
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          result = nil,
+          key, khash, value, object;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        key = keys[i];
 
-        if ((value = block(key, obj)) === $breaker) {
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        value = map[khash];
+        object = block(key, value);
+
+        if (object === $breaker) {
           return $breaker.$v;
         }
 
-        if (value === false || value === nil) {
+        if (object === false || object === nil) {
           keys.splice(i, 1);
-          delete map[key];
+          delete map[khash];
 
           length--;
           i--;
@@ -655,15 +962,26 @@ class Hash
 
   def shift
     %x{
-      var keys = self.keys, map = self.map;
+      var keys = self.keys,
+          _map = self.map,
+          smap = self.smap,
+          map, key, khash, value;
 
       if (keys.length) {
-        var key = keys[0], obj = map[key];
+        key = keys[0];
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+        value = map[khash];
 
-        delete map[key];
+        delete map[khash];
         keys.splice(0, 1);
 
-        return [key, obj];
+        return [key, value];
       }
 
       return nil;
@@ -676,11 +994,24 @@ class Hash
 
   def to_a
     %x{
-      var keys = self.keys, map = self.map, result = [];
+      var keys = self.keys,
+          _map = self.map,
+          smap = self.smap,
+          result = [],
+          map, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
-        result.push([key, map[key]]);
+        key = keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
+
+        result.push([key, map[khash]]);
       }
 
       return result;
@@ -689,10 +1020,15 @@ class Hash
 
   def to_h
     %x{
+      if (self.$$class === Opal.Hash) {
+        return self
+      }
+
       var hash   = new Opal.Hash.$$alloc,
           cloned = #{clone};
 
       hash.map  = cloned.map;
+      hash.smap = cloned.smap;
       hash.keys = cloned.keys;
       hash.none = cloned.none;
       hash.proc = cloned.proc;
@@ -715,11 +1051,24 @@ class Hash
 
   def values
     %x{
-      var map    = self.map,
-          result = [];
+      var _map = self.map,
+          smap = self.smap,
+          keys = self.keys,
+          result = [],
+          map, khash;
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          khash = key;
+          map = smap;
+        } else {
+          khash = key.$hash();
+          map = _map;
+        }
 
-      for (var key in map) {
-        result.push(map[key]);
+        result.push(map[khash]);
       }
 
       return result;