Bug 1502176 - Change assertThrows with type to assertThrowsInstanceOf. r=jorendorff

Differential Revision: https://phabricator.services.mozilla.com/D33554

--HG--
extra : moz-landing-system : lando

js/src/tests/non262/Math/Pow.js

@@ -49,7 +49,7 @@ a = c = e = 2;
 assertEq(a**/**b**/c/**/**/**d**/e, 16);
 
 // Two stars separated should not parse as exp operator
-assertThrows(function() { return Reflect.parse("2 * * 3"); }, SyntaxError);
+assertThrowsInstanceOf(function() { return Reflect.parse("2 * * 3"); }, SyntaxError);
 
 // Left-hand side expression must not be a unary expression.
 for (let unaryOp of ["delete", "typeof", "void", "+", "-", "!", "~"]) {

js/src/tests/non262/TypedArray/bug1526838.js

@@ -2,8 +2,8 @@
 
 const testArray = [1n];
 for (const constructor of anyTypedArrayConstructors) {
-    assertThrows(() => new constructor(testArray), TypeError);
-    assertThrows(() => new constructor(testArray.values()), TypeError);
+    assertThrowsInstanceOf(() => new constructor(testArray), TypeError);
+    assertThrowsInstanceOf(() => new constructor(testArray.values()), TypeError);
 }
 
 if (typeof reportCompare === "function")

js/src/tests/non262/TypedArray/constructor-byteoffsets-bounds.js

@@ -6,28 +6,28 @@ const ab = new ArrayBuffer(0);
 
 for (let TA of typedArrayConstructors) {
     // Test bound checks around INT32_MAX for |byteOffset| argument.
-    assertThrows(() => new TA(ab, 2**31 - TA.BYTES_PER_ELEMENT), RangeError);
-    assertThrows(() => new TA(ab, 2**31 - 1), RangeError);
-    assertThrows(() => new TA(ab, 2**31), RangeError);
-    assertThrows(() => new TA(ab, 2**31 + 1), RangeError);
-    assertThrows(() => new TA(ab, 2**31 + TA.BYTES_PER_ELEMENT), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**31 - TA.BYTES_PER_ELEMENT), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**31 - 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**31), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**31 + 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**31 + TA.BYTES_PER_ELEMENT), RangeError);
 
     // Test bound checks around UINT32_MAX for |byteOffset| argument.
-    assertThrows(() => new TA(ab, 2**32 - TA.BYTES_PER_ELEMENT), RangeError);
-    assertThrows(() => new TA(ab, 2**32 - 1), RangeError);
-    assertThrows(() => new TA(ab, 2**32), RangeError);
-    assertThrows(() => new TA(ab, 2**32 + 1), RangeError);
-    assertThrows(() => new TA(ab, 2**32 + TA.BYTES_PER_ELEMENT), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**32 - TA.BYTES_PER_ELEMENT), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**32 - 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**32), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**32 + 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 2**32 + TA.BYTES_PER_ELEMENT), RangeError);
 
     // Test bound checks around INT32_MAX for |length| argument.
-    assertThrows(() => new TA(ab, 0, 2**31 - 1), RangeError);
-    assertThrows(() => new TA(ab, 0, 2**31), RangeError);
-    assertThrows(() => new TA(ab, 0, 2**31 + 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**31 - 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**31), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**31 + 1), RangeError);
 
     // Test bound checks around UINT32_MAX for |length| argument.
-    assertThrows(() => new TA(ab, 0, 2**32 - 1), RangeError);
-    assertThrows(() => new TA(ab, 0, 2**32), RangeError);
-    assertThrows(() => new TA(ab, 0, 2**32 + 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**32 - 1), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**32), RangeError);
+    assertThrowsInstanceOf(() => new TA(ab, 0, 2**32 + 1), RangeError);
 }
 
 if (typeof reportCompare === "function")

js/src/tests/non262/TypedArray/constructor-length-too-large.js

@@ -8,8 +8,8 @@ const INT32_MAX = 2**31 - 1;
 
 // 22.2.4.2 TypedArray ( length )
 for (let TA of typedArrayConstructors) {
-    assertThrows(() => new TA(INT32_MAX), RangeError);
-    assertThrows(() => new TA(INT32_MAX >> Math.log2(TA.BYTES_PER_ELEMENT)), RangeError);
+    assertThrowsInstanceOf(() => new TA(INT32_MAX), RangeError);
+    assertThrowsInstanceOf(() => new TA(INT32_MAX >> Math.log2(TA.BYTES_PER_ELEMENT)), RangeError);
 }
 
 // Test disabled because allocating a 2**30 Int8Array easily leads to OOMs.
@@ -17,13 +17,13 @@ for (let TA of typedArrayConstructors) {
 // 22.2.4.3 TypedArray ( typedArray )
 // const largeInt8Array = new Int8Array(2**30);
 // for (let TA of typedArrayConstructors.filter(c => c.BYTES_PER_ELEMENT > 1)) {
-//     assertThrows(() => new TA(largeInt8Array), RangeError);
+//     assertThrowsInstanceOf(() => new TA(largeInt8Array), RangeError);
 // }
 
 // 22.2.4.4 TypedArray ( object )
 for (let TA of typedArrayConstructors) {
-    assertThrows(() => new TA({length: INT32_MAX}), RangeError);
-    assertThrows(() => new TA({length: INT32_MAX >> Math.log2(TA.BYTES_PER_ELEMENT)}), RangeError);
+    assertThrowsInstanceOf(() => new TA({length: INT32_MAX}), RangeError);
+    assertThrowsInstanceOf(() => new TA({length: INT32_MAX >> Math.log2(TA.BYTES_PER_ELEMENT)}), RangeError);
 }
 
 if (typeof reportCompare === "function")

js/src/tests/non262/TypedArray/of.js

@@ -16,8 +16,8 @@ for (var constructor of anyTypedArrayConstructors) {
     assertDeepEq(constructor.of("1", "2", "3"), new constructor([1, 2, 3]));
 
     // This method can't be transplanted to other constructors.
-    assertThrows(() => constructor.of.call(Array), TypeError);
-    assertThrows(() => constructor.of.call(Array, 1, 2, 3), TypeError);
+    assertThrowsInstanceOf(() => constructor.of.call(Array), TypeError);
+    assertThrowsInstanceOf(() => constructor.of.call(Array, 1, 2, 3), TypeError);
 
     var hits = 0;
     assertDeepEq(constructor.of.call(function(len) {

js/src/tests/non262/async-functions/EarlyErrors.js

@@ -4,7 +4,7 @@ var summary = "EarlyErrors for async function";
 print(BUGNUMBER + ": " + summary);
 
 function assertThrowsSE(code) {
-  assertThrows(() => Reflect.parse(code), SyntaxError);
+  assertThrowsInstanceOf(() => Reflect.parse(code), SyntaxError);
 }
 
 if (typeof Reflect !== "undefined" && Reflect.parse) {

js/src/tests/non262/async-functions/semantics.js

@@ -158,7 +158,7 @@ let arrowAwaitBlock = async () => { return await 2; };
 assertEventuallyEq(arrowAwaitBlock(), 2);
 
 // Async functions are not constructible
-assertThrows(() => {
+assertThrowsInstanceOf(() => {
   async function Person() {
 
   }

js/src/tests/non262/async-functions/syntax-arrow.js

@@ -15,23 +15,23 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
     Reflect.parse("async ({a}) => 1");
     Reflect.parse("async ({a, b}) => 1");
 
-    assertThrows(() => Reflect.parse("async await => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async (await) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ([await]) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ({await}) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async await => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async (await) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ([await]) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ({await}) => 1"), SyntaxError);
 
-    assertThrows(() => Reflect.parse("async (a=await) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ([a=await]) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ({a=await}) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async (a=await) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ([a=await]) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ({a=await}) => 1"), SyntaxError);
 
-    assertThrows(() => Reflect.parse("async (a=await 1) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ([a=await 1]) => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async ({a=await 1}) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async (a=await 1) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ([a=await 1]) => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async ({a=await 1}) => 1"), SyntaxError);
 
-    assertThrows(() => Reflect.parse("async [a] => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async [a, b] => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async {a} => 1"), SyntaxError);
-    assertThrows(() => Reflect.parse("async {a: b} => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async [a] => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async [a, b] => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async {a} => 1"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async {a: b} => 1"), SyntaxError);
 
     // Expression body.
     Reflect.parse("async a => a == b");
@@ -42,21 +42,21 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
     Reflect.parse("async a => async function() {}");
     Reflect.parse("async a => async function b() {}");
 
-    assertThrows(() => Reflect.parse("async a => async b"), SyntaxError);
-    assertThrows(() => Reflect.parse("async a => async function"), SyntaxError);
-    assertThrows(() => Reflect.parse("async a => async function()"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => async b"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => async function"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => async function()"), SyntaxError);
 
     // Expression body with `await`.
     Reflect.parse("async a => await 1");
     Reflect.parse("async a => await await 1");
     Reflect.parse("async a => await await await 1");
 
-    assertThrows(() => Reflect.parse("async a => await"), SyntaxError);
-    assertThrows(() => Reflect.parse("async a => await await"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => await"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => await await"), SyntaxError);
 
     // `await` is Unary Expression and it cannot have `async` function as an
     // operand.
-    assertThrows(() => Reflect.parse("async a => await async X => Y"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async a => await async X => Y"), SyntaxError);
     Reflect.parse("async a => await (async X => Y)");
     // But it can have `async` identifier as an operand.
     Reflect.parse("async async => await async");
@@ -75,10 +75,10 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
     Reflect.parse("async yield => {yield}");
     Reflect.parse("function* g() { async X => yield }");
 
-    assertThrows(() => Reflect.parse("'use strict'; async yield => X"), SyntaxError);
-    assertThrows(() => Reflect.parse("'use strict'; async (yield) => X"), SyntaxError);
-    assertThrows(() => Reflect.parse("'use strict'; async X => yield"), SyntaxError);
-    assertThrows(() => Reflect.parse("'use strict'; async X => {yield}"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; async yield => X"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; async (yield) => X"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; async X => yield"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; async X => {yield}"), SyntaxError);
 
     assertThrows(() => Reflect.parse("function* g() { async yield => X }"));
     assertThrows(() => Reflect.parse("function* g() { async (yield) => X }"));
@@ -97,7 +97,7 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
     // Async arrow function is assignment expression.
     Reflect.parse("a ? async () => {1} : b");
     Reflect.parse("a ? b : async () => {1}");
-    assertThrows(() => Reflect.parse("async () => {1} ? a : b"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async () => {1} ? a : b"), SyntaxError);
 }
 
 if (typeof reportCompare === "function")

js/src/tests/non262/async-functions/syntax-modules.js

@@ -6,24 +6,24 @@ print(BUGNUMBER + ": " + summary);
 if (typeof parseModule === "function") {
     parseModule("async function f() { await 3; }");
     parseModule("async function f() { await 3; }");
-    assertThrows(() => parseModule("var await = 5;"), SyntaxError);
-    assertThrows(() => parseModule("await;"), SyntaxError);
-    assertThrows(() => parseModule("await 5;"), SyntaxError);
-    assertThrows(() => parseModule("function f() { await 5; }"), SyntaxError);
-    assertThrows(() => parseModule("() => { await 5; }"), SyntaxError);
-    assertThrows(() => parseModule("export var await;"), SyntaxError);
-    assertThrows(() => parseModule("await => 1;"), SyntaxError);
-    assertThrows(() => parseModule("async function f() { function g() { await 3; } }"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("var await = 5;"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("await;"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("await 5;"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("function f() { await 5; }"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("() => { await 5; }"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("export var await;"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("await => 1;"), SyntaxError);
+    assertThrowsInstanceOf(() => parseModule("async function f() { function g() { await 3; } }"), SyntaxError);
 
     if (typeof Reflect !== "undefined" && Reflect.parse) {
         Reflect.parse("export async function f() {}", { target: "module" });
-        assertThrows(() => Reflect.parse("export async function() {}", { target: "module" }), SyntaxError);
+        assertThrowsInstanceOf(() => Reflect.parse("export async function() {}", { target: "module" }), SyntaxError);
 
         Reflect.parse("export default async function() {}", { target: "module" });
         Reflect.parse("export default async function f() {}", { target: "module" });
 
-        assertThrows(() => Reflect.parse("export default async function() { yield; }", { target: "module" }), SyntaxError);
-        assertThrows(() => Reflect.parse("export default async function() { yield = 1; }", { target: "module" }), SyntaxError);
+        assertThrowsInstanceOf(() => Reflect.parse("export default async function() { yield; }", { target: "module" }), SyntaxError);
+        assertThrowsInstanceOf(() => Reflect.parse("export default async function() { yield = 1; }", { target: "module" }), SyntaxError);
     }
 }
 

js/src/tests/non262/async-functions/syntax.js

@@ -19,30 +19,30 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
 
     // `await` handling for function declaration name inherits.
     assertEq(Reflect.parse("async function await() {}").body[0].id.name, "await");
-    assertThrows(() => Reflect.parse("async function f() { async function await() {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function f() { async function await() {} }"), SyntaxError);
 
     // `await` is not allowed in function expression name.
-    assertThrows(() => Reflect.parse("(async function await() {})"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("(async function await() {})"), SyntaxError);
 
     // Awaiting not directly inside an async function is not allowed
-    assertThrows(() => Reflect.parse("await 4;"), SyntaxError);
-    assertThrows(() => Reflect.parse("function a() { await 4; }"), SyntaxError);
-    assertThrows(() => Reflect.parse("function* a() { await 4; }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function k() { function a() { await 4; } }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("await 4;"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("function a() { await 4; }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("function* a() { await 4; }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function k() { function a() { await 4; } }"), SyntaxError);
 
     // Await is not allowed as a default expr.
-    assertThrows(() => Reflect.parse("async function a(k = await 3) {}"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { async function b(k = await 3) {} }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { async function b(k = [await 3]) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a(k = await 3) {}"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b(k = await 3) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b(k = [await 3]) {} }"), SyntaxError);
 
-    assertThrows(() => Reflect.parse("async function a() { async function b([k = await 3]) {} }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { async function b([k = [await 3]]) {} }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { async function b({k = await 3}) {} }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { async function b({k = [await 3]}) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b([k = await 3]) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b([k = [await 3]]) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b({k = await 3}) {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { async function b({k = [await 3]}) {} }"), SyntaxError);
 
     // Await is not legal as an identifier in an async function.
-    assertThrows(() => Reflect.parse("async function a() { var await = 4; }"), SyntaxError);
-    assertThrows(() => Reflect.parse("async function a() { return await; }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { var await = 4; }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("async function a() { return await; }"), SyntaxError);
 
     // Await is still available as an identifier name in strict mode code.
     Reflect.parse("function a() { 'use strict'; var await = 3; }");

js/src/tests/non262/async-functions/yield.js

@@ -11,33 +11,33 @@ function testPassArgsBody(argsbody) {
 }
 
 function testErrorArgsBody(argsbody, prefix="") {
-    assertThrows(() => Reflect.parse(`${prefix} async function a${argsbody}`), SyntaxError);
-    assertThrows(() => Reflect.parse(`${prefix} (async function a${argsbody})`), SyntaxError);
-    assertThrows(() => Reflect.parse(`${prefix} (async function ${argsbody})`), SyntaxError);
-    assertThrows(() => Reflect.parse(`${prefix} ({ async m${argsbody} })`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`${prefix} async function a${argsbody}`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`${prefix} (async function a${argsbody})`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`${prefix} (async function ${argsbody})`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`${prefix} ({ async m${argsbody} })`), SyntaxError);
 }
 
 function testErrorArgsBodyStrict(argsbody) {
     testErrorArgsBody(argsbody);
     testErrorArgsBody(argsbody, "'use strict'; ");
-    assertThrows(() => Reflect.parse(`class X { async m${argsbody} }`), SyntaxError);
-    assertThrows(() => Reflect.parse(`class X { static async m${argsbody} }`), SyntaxError);
-    assertThrows(() => Reflect.parse(`export default async function ${argsbody}`, { target: "module" }), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`class X { async m${argsbody} }`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`class X { static async m${argsbody} }`), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse(`export default async function ${argsbody}`, { target: "module" }), SyntaxError);
 }
 
 if (typeof Reflect !== "undefined" && Reflect.parse) {
     // `yield` handling is inherited in async function declaration name.
     Reflect.parse("async function yield() {}");
     Reflect.parse("function f() { async function yield() {} }");
-    assertThrows(() => Reflect.parse("function* g() { async function yield() {} }"), SyntaxError);
-    assertThrows(() => Reflect.parse("'use strict'; async function yield() {}"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("function* g() { async function yield() {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; async function yield() {}"), SyntaxError);
 
     // `yield` is treated as an identifier in an async function expression name.
     // `yield` is not allowed as an identifier in strict code.
     Reflect.parse("(async function yield() {});");
     Reflect.parse("function f() { (async function yield() {}); }");
     Reflect.parse("function* g() { (async function yield() {}); }");
-    assertThrows(() => Reflect.parse("'use strict'; (async function yield() {});"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; (async function yield() {});"), SyntaxError);
 
     // `yield` handling is inherited in async method name.
     Reflect.parse("({ async yield() {} });");
@@ -49,8 +49,8 @@ if (typeof Reflect !== "undefined" && Reflect.parse) {
     Reflect.parse("({ async [yield]() {} });");
     Reflect.parse("function f() { ({ async [yield]() {} }); }");
     Reflect.parse("function* g() { ({ async [yield]() {} }); }");
-    assertThrows(() => Reflect.parse("'use strict'; ({ async [yield]() {} });"), SyntaxError);
-    assertThrows(() => Reflect.parse("class X { async [yield]() {} }"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("'use strict'; ({ async [yield]() {} });"), SyntaxError);
+    assertThrowsInstanceOf(() => Reflect.parse("class X { async [yield]() {} }"), SyntaxError);
 
     // `yield` is treated as an identifier in an async function parameter
     // `yield` is not allowed as an identifier in strict code.

js/src/tests/non262/extensions/file-mapped-arraybuffers.js

@@ -7,16 +7,6 @@ function viewToString(view)
   return String.fromCharCode.apply(null, view);
 }
 
-function assertThrows(f, wantException)
-{
-    try {
-      f();
-      assertEq(true, false, "expected " + wantException + " exception");
-    } catch (e) {
-      assertEq(e.name, wantException.name, e.toString());
-    }
-}
-
 function test() {
     var filename = "file-mapped-arraybuffers.txt";
     var buffer = createMappedArrayBuffer(filename);
@@ -32,8 +22,8 @@ function test() {
     assertEq(viewToString(view), "01234567");
 
     // Check that invalid sizes and offsets are caught
-    assertThrows(() => createMappedArrayBuffer("empty.txt", 8), RangeError);
-    assertThrows(() => createMappedArrayBuffer("empty.txt", 0, 8), Error);
+    assertThrowsInstanceOf(() => createMappedArrayBuffer("empty.txt", 8), RangeError);
+    assertThrowsInstanceOf(() => createMappedArrayBuffer("empty.txt", 0, 8), Error);
 }
 
 if (getBuildConfiguration()["mapped-array-buffer"])

js/src/tests/non262/generators/syntax.js

@@ -49,14 +49,14 @@ function* g() {
     yield *
     foo
 }
-assertThrows(() => Function("function* g() { yield\n* foo }"), SyntaxError);
+assertThrowsInstanceOf(() => Function("function* g() { yield\n* foo }"), SyntaxError);
 assertIteratorNext(function*(){
                        yield
                        3
                    }(), undefined)
 
 // A YieldExpression is not a LogicalORExpression.
-assertThrows(() => Function("function* g() { yield ? yield : yield }"), SyntaxError);
+assertThrowsInstanceOf(() => Function("function* g() { yield ? yield : yield }"), SyntaxError);
 
 // You can have a generator in strict mode.
 function* g() { "use strict"; yield 3; yield 4; }

js/src/tests/non262/pipeline/parse-error.js

@@ -5,13 +5,13 @@ print(BUGNUMBER + ": " + summary);
 
 if (hasPipeline()) {
     // Invalid Token
-    assertThrows(() => Function("2 | > parseInt"), SyntaxError);
-    assertThrows(() => Function("2 ||> parseInt"), SyntaxError);
-    assertThrows(() => Function("2 |>> parseInt"), SyntaxError);
-    assertThrows(() => Function("2 <| parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 | > parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 ||> parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 |>> parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 <| parseInt"), SyntaxError);
     // Invalid Syntax
-    assertThrows(() => Function("2 |>"), SyntaxError);
-    assertThrows(() => Function("|> parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 |>"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("|> parseInt"), SyntaxError);
 }
 
 if (typeof reportCompare === "function")

js/src/tests/shell.js

@@ -146,6 +146,9 @@
   global.assertEqArray = assertEqArray;
 
   function assertThrows(f) {
+    if (arguments.length != 1) {
+      throw new Error("Too many arguments to assertThrows; maybe you meant assertThrowsInstanceOf?");
+    }
     var ok = false;
     try {
       f();