Add fix and test for immutable-js#1175

leebyron · leebyron · commit 6384ea3a6250 · 2017-09-28T21:02:21.000-07:00
Closes immutable-js#1175
diff --git a/__tests__/issues.ts b/__tests__/issues.ts
@@ -2,7 +2,23 @@
 ///<reference path='../resources/jest.d.ts'/>
 
 declare var Symbol: any;
-import { List, OrderedMap, Seq } from '../';
+import { List, OrderedMap, Seq, Set } from '../';
+
+describe('Issue #1175', () => {
+  it('invalid hashCode() response should not infinitly recurse', () => {
+    class BadHash {
+      equals() {
+        return false;
+      }
+      hashCode() {
+        return 2 ** 32;
+      }
+    }
+
+    const set = Set([new BadHash()]);
+    expect(set.size).toEqual(1);
+  });
+});
 
 describe('Issue #1220 : Seq.rest() throws an exception when invoked on a single item sequence ', () => {
   it('should be iterable', () => {
diff --git a/dist/immutable-nonambient.d.ts b/dist/immutable-nonambient.d.ts
@@ -349,6 +349,9 @@
      * assert.equal(set.has(b), true);
      * ```
      *
+     * Note: hashCode() MUST return a Uint32 number. The easiest way to
+     * guarantee this is to return `myHash | 0` from a custom implementation.
+     *
      * If two values have the same `hashCode`, they are [not guaranteed
      * to be equal][Hash Collision]. If two values have different `hashCode`s,
      * they must not be equal.
diff --git a/dist/immutable.d.ts b/dist/immutable.d.ts
@@ -349,6 +349,9 @@ declare module Immutable {
      * assert.equal(set.has(b), true);
      * ```
      *
+     * Note: hashCode() MUST return a Uint32 number. The easiest way to
+     * guarantee this is to return `myHash | 0` from a custom implementation.
+     *
      * If two values have the same `hashCode`, they are [not guaranteed
      * to be equal][Hash Collision]. If two values have different `hashCode`s,
      * they must not be equal.
diff --git a/dist/immutable.es.js b/dist/immutable.es.js
@@ -859,7 +859,8 @@ function hash(o) {
       : hashString(o);
   }
   if (typeof o.hashCode === 'function') {
-    return o.hashCode();
+    // Drop any high bits from accidentally long hash codes.
+    return smi(o.hashCode());
   }
   if (type === 'object') {
     return hashJSObj(o);
diff --git a/dist/immutable.js b/dist/immutable.js
@@ -865,7 +865,8 @@ function hash(o) {
       : hashString(o);
   }
   if (typeof o.hashCode === 'function') {
-    return o.hashCode();
+    // Drop any high bits from accidentally long hash codes.
+    return smi(o.hashCode());
   }
   if (type === 'object') {
     return hashJSObj(o);
diff --git a/dist/immutable.min.js b/dist/immutable.min.js
diff --git a/pages/lib/genTypeDefData.js b/pages/lib/genTypeDefData.js
@@ -384,10 +384,12 @@ function DocVisitor(source) {
           members: [
             {
               index: true,
-              params: [{
-                name: 'key',
-                type: { k: TypeKind.String }
-              }],
+              params: [
+                {
+                  name: 'key',
+                  type: { k: TypeKind.String }
+                }
+              ],
               type: parseType(node.type)
             }
           ]
diff --git a/src/Hash.js b/src/Hash.js
@@ -43,7 +43,8 @@ export function hash(o) {
       : hashString(o);
   }
   if (typeof o.hashCode === 'function') {
-    return o.hashCode();
+    // Drop any high bits from accidentally long hash codes.
+    return smi(o.hashCode());
   }
   if (type === 'object') {
     return hashJSObj(o);
diff --git a/type-definitions/Immutable.d.ts b/type-definitions/Immutable.d.ts
@@ -349,6 +349,9 @@ declare module Immutable {
      * assert.equal(set.has(b), true);
      * ```
      *
+     * Note: hashCode() MUST return a Uint32 number. The easiest way to
+     * guarantee this is to return `myHash | 0` from a custom implementation.
+     *
      * If two values have the same `hashCode`, they are [not guaranteed
      * to be equal][Hash Collision]. If two values have different `hashCode`s,
      * they must not be equal.

Original file line number	Diff line number	Diff line change
`@@ -859,7 +859,8 @@ function hash(o) {`
`859`	`859`	`: hashString(o);`
`860`	`860`	`}`
`861`	`861`	`if (typeof o.hashCode === 'function') {`
`862`		`- return o.hashCode();`
	`862`	`+ // Drop any high bits from accidentally long hash codes.`
	`863`	`+ return smi(o.hashCode());`
`863`	`864`	`}`
`864`	`865`	`if (type === 'object') {`
`865`	`866`	`return hashJSObj(o);`
Original file line number	Diff line number	Diff line change
`@@ -865,7 +865,8 @@ function hash(o) {`
`865`	`865`	`: hashString(o);`
`866`	`866`	`}`
`867`	`867`	`if (typeof o.hashCode === 'function') {`
`868`		`- return o.hashCode();`
	`868`	`+ // Drop any high bits from accidentally long hash codes.`
	`869`	`+ return smi(o.hashCode());`
`869`	`870`	`}`
`870`	`871`	`if (type === 'object') {`
`871`	`872`	`return hashJSObj(o);`
Original file line number	Diff line number	Diff line change
`@@ -384,10 +384,12 @@ function DocVisitor(source) {`
`384`	`384`	`members: [`
`385`	`385`	`{`
`386`	`386`	`index: true,`
`387`		`- params: [{`
`388`		`- name: 'key',`
`389`		`- type: { k: TypeKind.String }`
`390`		`- }],`
	`387`	`+ params: [`
	`388`	`+ {`
	`389`	`+ name: 'key',`
	`390`	`+ type: { k: TypeKind.String }`
	`391`	`+ }`
	`392`	`+ ],`
`391`	`393`	`type: parseType(node.type)`
`392`	`394`	`}`
`393`	`395`	`]`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,8 @@ export function hash(o) {`
`43`	`43`	`: hashString(o);`
`44`	`44`	`}`
`45`	`45`	`if (typeof o.hashCode === 'function') {`
`46`		`- return o.hashCode();`
	`46`	`+ // Drop any high bits from accidentally long hash codes.`
	`47`	`+ return smi(o.hashCode());`
`47`	`48`	`}`
`48`	`49`	`if (type === 'object') {`
`49`	`50`	`return hashJSObj(o);`