Hash symbols as objects

Author: conartist6

__tests__/hash.ts

@@ -36,6 +36,13 @@ describe('hash', () => {
     expect(hash(objA)).not.toBe(hash(objB));
   });
 
+  it('generates different hashes for different symbols', () => {
+    const symA = Symbol();
+    const symB = Symbol();
+    expect(hash(symA)).toBe(hash(symA));
+    expect(hash(symA)).not.toBe(hash(symB));
+  });
+
   it('generates different hashes for different functions', () => {
     const funA = () => {
       return;

src/Hash.js

@@ -23,18 +23,18 @@ export function hash(o) {
         ? cachedHashString(o)
         : hashString(o);
     case 'object':
-    case 'function':
       if (o === null) {
         return 0x42108422;
       }
+      // falls through
+    case 'function':
       if (typeof o.hashCode === 'function') {
         // Drop any high bits from accidentally long hash codes.
         return smi(o.hashCode(o));
       }
-      if (o.valueOf !== defaultValueOf && typeof o.valueOf === 'function') {
-        o = o.valueOf(o);
-      }
-      return hashJSObj(o);
+      return hashJSObj(asPrimitive(o));
+    case 'symbol':
+      return hashSymbol(asPrimitive(o));
     case 'undefined':
       return 0x42108423;
     default:
@@ -90,6 +90,19 @@ function hashString(string) {
   return smi(hashed);
 }
 
+function hashSymbol(sym) {
+  let hashed = symbolMap[sym];
+  if (hashed !== undefined) {
+    return hashed;
+  }
+
+  hashed = nextHash();
+
+  symbolMap[sym] = hashed;
+
+  return hashed;
+}
+
 function hashJSObj(obj) {
   let hashed;
   if (usingWeakMap) {
@@ -116,10 +129,7 @@ function hashJSObj(obj) {
     }
   }
 
-  hashed = ++objHashUID;
-  if (objHashUID & 0x40000000) {
-    objHashUID = 0;
-  }
+  hashed = nextHash();
 
   if (usingWeakMap) {
     weakMap.set(obj, hashed);
@@ -186,14 +196,32 @@ function getIENodeHash(node) {
   }
 }
 
+function asPrimitive(obj) {
+  return (
+    obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'
+      ? obj.valueOf(obj)
+      : obj
+  );
+}
+
+function nextHash() {
+  const nextHash = ++_objHashUID;
+  if (_objHashUID & 0x40000000) {
+    _objHashUID = 0;
+  }
+  return nextHash;
+}
+
 // If possible, use a WeakMap.
 const usingWeakMap = typeof WeakMap === 'function';
 let weakMap;
 if (usingWeakMap) {
   weakMap = new WeakMap();
 }
 
-let objHashUID = 0;
+const symbolMap = Object.create(null);
+
+let _objHashUID = 0;
 
 let UID_HASH_KEY = '__immutablehash__';
 if (typeof Symbol === 'function') {