Replace assertThrowsInstanceOf with assert.throws in staging/sm

harness/sm/non262-shell.js

@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*---
-defines: [assertThrowsValue, assertThrowsInstanceOfWithMessageCheck, assertThrowsInstanceOf]
+defines: [assertThrowsValue]
 allow_unused: True
 ---*/
 
@@ -29,33 +29,4 @@ allow_unused: True
       throw new Error(fullmsg);
     };
   }
-
-  if (typeof globalThis.assertThrowsInstanceOfWithMessageCheck === 'undefined') {
-    globalThis.assertThrowsInstanceOfWithMessageCheck = function assertThrowsInstanceOfWithMessageCheck(f, ctor, check, msg) {
-      var fullmsg;
-      try {
-        f();
-      } catch (exc) {
-        if (!(exc instanceof ctor))
-          fullmsg = `Assertion failed: expected exception ${ctor.name}, got ${exc}`;
-        else {
-          // Do not test error messages
-          return;
-        }
-      }
-
-      if (fullmsg === undefined)
-        fullmsg = `Assertion failed: expected exception ${ctor.name}, no exception thrown`;
-      if (msg !== undefined)
-        fullmsg += " - " + msg;
-
-      throw new Error(fullmsg);
-    };
-  }
-
-  if (typeof globalThis.assertThrowsInstanceOf === 'undefined') {
-    globalThis.assertThrowsInstanceOf = function assertThrowsInstanceOf(f, ctor, msg) {
-      assertThrowsInstanceOfWithMessageCheck(f, ctor, _ => true, msg);
-    };
-  }
 })();

test/staging/sm/ArrayBuffer/constructorNotCallable.js

@@ -9,9 +9,9 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(() => ArrayBuffer(), TypeError);
-assertThrowsInstanceOf(() => ArrayBuffer(1), TypeError);
-assertThrowsInstanceOf(() => ArrayBuffer.call(null), TypeError);
-assertThrowsInstanceOf(() => ArrayBuffer.apply(null, []), TypeError);
-assertThrowsInstanceOf(() => Reflect.apply(ArrayBuffer, null, []), TypeError);
+assert.throws(TypeError, () => ArrayBuffer());
+assert.throws(TypeError, () => ArrayBuffer(1));
+assert.throws(TypeError, () => ArrayBuffer.call(null));
+assert.throws(TypeError, () => ArrayBuffer.apply(null, []));
+assert.throws(TypeError, () => Reflect.apply(ArrayBuffer, null, []));
 

test/staging/sm/ArrayBuffer/slice-species.js

@@ -105,7 +105,7 @@ for (let [ctor, answer] of tests) {
     a.constructor = {
       [Symbol.species]: species
     };
-    assertThrowsInstanceOf(() => a.slice(8, 16), TypeError);
+    assert.throws(TypeError, () => a.slice(8, 16));
   }
 
   // undefined constructor
@@ -119,7 +119,7 @@ for (let [ctor, answer] of tests) {
   for (let ctor of [null, 0, 1.1, true, false, "a", Symbol.iterator]) {
     a = arr.buffer;
     a.constructor = ctor;
-    assertThrowsInstanceOf(() => a.slice(8, 16), TypeError);
+    assert.throws(TypeError, () => a.slice(8, 16));
   }
 
   // @@species from different global

test/staging/sm/AsyncGenerators/create-function-parse-before-getprototype.js

@@ -20,9 +20,9 @@ var newTarget = Object.defineProperty(function(){}.bind(), "prototype", {
 
 var AsyncGenerator = async function*(){}.constructor;
 
-assertThrowsInstanceOf(() => {
+assert.throws(SyntaxError, () => {
     Reflect.construct(AsyncGenerator, ["@error"], newTarget);
-}, SyntaxError);
+});
 
 assert.sameValue(getProtoCalled, false);
 

test/staging/sm/AsyncGenerators/for-await-bad-syntax.js

@@ -13,10 +13,10 @@ var AsyncGenerator = async function*(){}.constructor;
 
 function assertSyntaxError(code) {
     var functionCode = `async function* f() { ${code} }`;
-    assertThrowsInstanceOf(() => AsyncGenerator(code), SyntaxError, "AsyncGenerator:" + code);
-    assertThrowsInstanceOf(() => eval(functionCode), SyntaxError, "eval:" + functionCode);
+    assert.throws(SyntaxError, () => AsyncGenerator(code), "AsyncGenerator:" + code);
+    assert.throws(SyntaxError, () => eval(functionCode), "eval:" + functionCode);
     var ieval = eval;
-    assertThrowsInstanceOf(() => ieval(functionCode), SyntaxError, "indirect eval:" + functionCode);
+    assert.throws(SyntaxError, () => ieval(functionCode), "indirect eval:" + functionCode);
 }
 
 assertSyntaxError(`for await (;;) ;`);

test/staging/sm/Atomics/detached-buffers.js

@@ -32,71 +32,71 @@ function badValue(ta) {
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.load(ta, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.load(ta, badValue(ta)));
 }
 
 // Atomics.store
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.store(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.store(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.store(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.store(ta, 0, badValue(ta)));
 }
 
 // Atomics.compareExchange
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.compareExchange(ta, badValue(ta), 0, 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.compareExchange(ta, 0, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.compareExchange(ta, 0, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.compareExchange(ta, badValue(ta), 0, 0));
+  assert.throws(TypeError, () => Atomics.compareExchange(ta, 0, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.compareExchange(ta, 0, 0, badValue(ta)));
 }
 
 // Atomics.exchange
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.exchange(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.exchange(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.exchange(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.exchange(ta, 0, badValue(ta)));
 }
 
 // Atomics.add
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.add(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.add(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.add(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.add(ta, 0, badValue(ta)));
 }
 
 // Atomics.sub
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.sub(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.sub(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.sub(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.sub(ta, 0, badValue(ta)));
 }
 
 // Atomics.and
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.and(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.and(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.and(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.and(ta, 0, badValue(ta)));
 }
 
 // Atomics.or
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.or(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.or(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.or(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.or(ta, 0, badValue(ta)));
 }
 
 // Atomics.xor
 for (let TA of intArrayConstructors) {
   let ta = new TA(1);
 
-  assertThrowsInstanceOf(() => Atomics.xor(ta, badValue(ta), 0), TypeError);
-  assertThrowsInstanceOf(() => Atomics.xor(ta, 0, badValue(ta)), TypeError);
+  assert.throws(TypeError, () => Atomics.xor(ta, badValue(ta), 0));
+  assert.throws(TypeError, () => Atomics.xor(ta, 0, badValue(ta)));
 }
 

test/staging/sm/DataView/detach-after-construction.js

@@ -14,5 +14,5 @@ var bufView = new DataView(buf);
 
 $262.detachArrayBuffer(buf);
 
-assertThrowsInstanceOf(() => bufView.getInt8(0), TypeError);
+assert.throws(TypeError, () => bufView.getInt8(0));
 

test/staging/sm/DataView/get-set-index-range.js

@@ -14,12 +14,12 @@ var view = new DataView(buffer);
 
 function check(view) {
     for (let fun of ['getInt8', 'setInt8', 'getInt16', 'setInt16']) {
-        assertThrowsInstanceOf(() => view[fun](-10), RangeError);
-        assertThrowsInstanceOf(() => view[fun](-Infinity), RangeError);
-        assertThrowsInstanceOf(() => view[fun](Infinity), RangeError);
+        assert.throws(RangeError, () => view[fun](-10));
+        assert.throws(RangeError, () => view[fun](-Infinity));
+        assert.throws(RangeError, () => view[fun](Infinity));
 
-        assertThrowsInstanceOf(() => view[fun](Math.pow(2, 53)), RangeError);
-        assertThrowsInstanceOf(() => view[fun](Math.pow(2, 54)), RangeError);
+        assert.throws(RangeError, () => view[fun](Math.pow(2, 53)));
+        assert.throws(RangeError, () => view[fun](Math.pow(2, 54)));
     }
 }
 
@@ -38,9 +38,9 @@ if ('$262.detachArrayBuffer' in this) {
 
     check(view);
 
-    assertThrowsInstanceOf(() => view.getInt8(0), TypeError);
-    assertThrowsInstanceOf(() => view.setInt8(0, 0), TypeError);
-    assertThrowsInstanceOf(() => view.getInt8(Math.pow(2, 53) - 1), TypeError);
-    assertThrowsInstanceOf(() => view.setInt8(Math.pow(2, 53) - 1, 0), TypeError);
+    assert.throws(TypeError, () => view.getInt8(0));
+    assert.throws(TypeError, () => view.setInt8(0, 0));
+    assert.throws(TypeError, () => view.getInt8(Math.pow(2, 53) - 1));
+    assert.throws(TypeError, () => view.setInt8(Math.pow(2, 53) - 1, 0));
 }
 

test/staging/sm/Date/to-temporal-instant.js

@@ -27,7 +27,7 @@ let minusOne = Temporal.Duration.from({nanoseconds: -1});
 //Test invalid date
 {
     const invalidDate = new Date(NaN);
-    assertThrowsInstanceOf(() => invalidDate.toTemporalInstant(), RangeError);
+    assert.throws(RangeError, () => invalidDate.toTemporalInstant());
 }
 
 //Test Temporal.Instant properties
@@ -62,11 +62,11 @@ let minusOne = Temporal.Duration.from({nanoseconds: -1});
     assert.sameValue(max.subtract(one).epochNanoseconds, max.epochNanoseconds - 1n);
 
     // Subtracting one from the minimum instant.
-    assertThrowsInstanceOf(() => min.add(minusOne), RangeError);
-    assertThrowsInstanceOf(() => min.subtract(one), RangeError);
+    assert.throws(RangeError, () => min.add(minusOne));
+    assert.throws(RangeError, () => min.subtract(one));
 
     // Adding one to the maximum instant.
-    assertThrowsInstanceOf(() => max.add(one), RangeError);
-    assertThrowsInstanceOf(() => max.subtract(minusOne), RangeError);
+    assert.throws(RangeError, () => max.add(one));
+    assert.throws(RangeError, () => max.subtract(minusOne));
 }
 

test/staging/sm/Date/toISOString-01.js

@@ -49,13 +49,13 @@ var maxDateExtended = utc(+275760, 9, 13, 0, 0, 0, 0);
 assert.sameValue(maxDateExtended, +8.64e15);
 assert.sameValue(iso(maxDateExtended - 1), "+275760-09-12T23:59:59.999Z");
 assert.sameValue(iso(maxDateExtended    ), "+275760-09-13T00:00:00.000Z");
-assertThrowsInstanceOf(() => iso(maxDateExtended + 1), RangeError);
+assert.throws(RangeError, () => iso(maxDateExtended + 1));
 
 
 // Values around minimum date for extended iso format.
 var minDateExtended = utc(-271821, 4, 20, 0, 0, 0, 0);
 assert.sameValue(minDateExtended, -8.64e15);
-assertThrowsInstanceOf(() => iso(minDateExtended - 1), RangeError);
+assert.throws(RangeError, () => iso(minDateExtended - 1));
 assert.sameValue(iso(minDateExtended    ), "-271821-04-20T00:00:00.000Z");
 assert.sameValue(iso(minDateExtended + 1), "-271821-04-20T00:00:00.001Z");
 

test/staging/sm/Date/toPrimitive.js

@@ -13,8 +13,8 @@ esid: pending
 
 // The toPrimitive method throws if the this value isn't an object.
 var toPrimitive = Date.prototype[Symbol.toPrimitive];
-assertThrowsInstanceOf(() => toPrimitive.call(undefined, "default"), TypeError);
-assertThrowsInstanceOf(() => toPrimitive.call(3, "default"), TypeError);
+assert.throws(TypeError, () => toPrimitive.call(undefined, "default"));
+assert.throws(TypeError, () => toPrimitive.call(3, "default"));
 
 // It doesn't have to be a Date object, though.
 var obj = {
@@ -26,11 +26,11 @@ assert.sameValue(toPrimitive.call(obj, "string"), "str");
 assert.sameValue(toPrimitive.call(obj, "default"), "str");
 
 // It throws if the hint argument is missing or not one of the three allowed values.
-assertThrowsInstanceOf(() => toPrimitive.call(obj), TypeError);
-assertThrowsInstanceOf(() => toPrimitive.call(obj, undefined), TypeError);
-assertThrowsInstanceOf(() => toPrimitive.call(obj, "boolean"), TypeError);
-assertThrowsInstanceOf(() => toPrimitive.call(obj, ["number"]), TypeError);
-assertThrowsInstanceOf(() => toPrimitive.call(obj, {toString() { throw "FAIL"; }}), TypeError);
+assert.throws(TypeError, () => toPrimitive.call(obj));
+assert.throws(TypeError, () => toPrimitive.call(obj, undefined));
+assert.throws(TypeError, () => toPrimitive.call(obj, "boolean"));
+assert.throws(TypeError, () => toPrimitive.call(obj, ["number"]));
+assert.throws(TypeError, () => toPrimitive.call(obj, {toString() { throw "FAIL"; }}));
 
 // The next few tests cover the OrdinaryToPrimitive algorithm, specified in
 // ES6 7.1.1 ToPrimitive(input [, PreferredType]).
@@ -61,7 +61,7 @@ assert.sameValue(dateobj[Symbol.toPrimitive]("number"), 15);
 
 // If neither is callable, it throws a TypeError.
 Date.prototype.toString = "ponies";
-assertThrowsInstanceOf(() => dateobj[Symbol.toPrimitive]("default"), TypeError);
+assert.throws(TypeError, () => dateobj[Symbol.toPrimitive]("default"));
 
 // Surface features.
 assert.sameValue(toPrimitive.name, "[Symbol.toPrimitive]");

test/staging/sm/Date/toString-generic.js

@@ -17,8 +17,8 @@ var summary = 'Date.prototype.toString is a generic function';
 print(BUGNUMBER + ": " + summary);
 
 for (var thisValue of [{}, [], /foo/, Date.prototype, new Proxy(new Date(), {})])
-  assertThrowsInstanceOf(() => Date.prototype.toString.call(thisValue), TypeError);
+  assert.throws(TypeError, () => Date.prototype.toString.call(thisValue));
 
 for (var prim of [null, undefined, 0, 1.2, true, false, "foo", Symbol.iterator])
-  assertThrowsInstanceOf(() => Date.prototype.toString.call(prim), TypeError);
+  assert.throws(TypeError, () => Date.prototype.toString.call(prim));
 

test/staging/sm/Error/AggregateError.js

@@ -19,8 +19,8 @@ assert.sameValue(AggregateError.prototype.name, "AggregateError");
 assert.sameValue(AggregateError.prototype.message, "");
 
 // The |errors| argument is mandatory.
-assertThrowsInstanceOf(() => new AggregateError(), TypeError);
-assertThrowsInstanceOf(() => AggregateError(), TypeError);
+assert.throws(TypeError, () => new AggregateError());
+assert.throws(TypeError, () => AggregateError());
 
 // The .errors data property is an array object.
 {

test/staging/sm/JSON/parse-with-source.js

@@ -102,7 +102,7 @@ esid: pending
     }
 
     assert.sameValue(true, Object.isFrozen(JSON.rawJSON('"shouldBeFrozen"')));
-    assertThrowsInstanceOf(() => JSON.rawJSON(), SyntaxError);
+    assert.throws(SyntaxError, () => JSON.rawJSON());
     assertIsRawJson(JSON.rawJSON(1, 2), '1');
 })();
 
@@ -125,9 +125,9 @@ esid: pending
     assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
     assertErrorComesFromCorrectRealm = (fun, thisRealmType) => {
-        assertThrowsInstanceOf(() => fun(this), thisRealmType,
+        assert.throws(thisRealmType, () => fun(this),
             `${thisRealmType.name} should come from this realm.`);
-        assertThrowsInstanceOf(() => fun(otherGlobal), otherGlobal[thisRealmType.name],
+        assert.throws(otherGlobal[thisRealmType.name], () => fun(otherGlobal),
             `${thisRealmType.name} should come from the other realm.`);
     }
 

test/staging/sm/Map/constructor-iterator-close.js

@@ -61,7 +61,7 @@ function test(ctors, { nextVal=undefined,
             }
             assert.sameValue(caught, true);
         } else if (exceptionType) {
-            assertThrowsInstanceOf(() => new ctor(iterable), exceptionType);
+            assert.throws(exceptionType, () => new ctor(iterable));
         } else {
             new ctor(iterable);
         }

test/staging/sm/Map/constructor-iterator-primitive.js

@@ -37,7 +37,7 @@ for (let ctor of ctors) {
                 return primitive;
             }
         };
-        assertThrowsInstanceOf(() => new ctor(arg), TypeError);
+        assert.throws(TypeError, () => new ctor(arg));
     }
 }
 

test/staging/sm/Number/20.1.3.2-toExponential.js

@@ -51,7 +51,7 @@ assertThrowsValue(
   "hello");
 
 // Not a number throws TypeError
-assertThrowsInstanceOf(() => Number.prototype.toExponential.call("Hello"), TypeError);
+assert.throws(TypeError, () => Number.prototype.toExponential.call("Hello"));
 
 if (typeof assert.sameValue === "function") {
 }

test/staging/sm/Number/20.1.3.2-toPrecision.js

@@ -51,7 +51,7 @@ assertThrowsValue(
   "hello");
 
 // Not a number throws TypeError
-assertThrowsInstanceOf(() => Number.prototype.toPrecision.call("Hello"), TypeError);
+assert.throws(TypeError, () => Number.prototype.toPrecision.call("Hello"));
 
 if (typeof assert.sameValue === "function") {
 }

test/staging/sm/Number/20.1.3.3-toFixed.js

@@ -15,9 +15,9 @@ assert.sameValue(Number.prototype.toFixed.call(-Infinity), "-Infinity");
 assert.sameValue(Number.prototype.toFixed.call(Infinity), "Infinity");
 assert.sameValue(Number.prototype.toFixed.call(NaN), "NaN");
 
-assertThrowsInstanceOf(() => Number.prototype.toFixed.call(-Infinity, 555), RangeError);
-assertThrowsInstanceOf(() => Number.prototype.toFixed.call(Infinity, 555), RangeError);
-assertThrowsInstanceOf(() => Number.prototype.toFixed.call(NaN, 555), RangeError);
+assert.throws(RangeError, () => Number.prototype.toFixed.call(-Infinity, 555));
+assert.throws(RangeError, () => Number.prototype.toFixed.call(Infinity, 555));
+assert.throws(RangeError, () => Number.prototype.toFixed.call(NaN, 555));
 
-assertThrowsInstanceOf(() => Number.prototype.toFixed.call("Hello"), TypeError);
+assert.throws(TypeError, () => Number.prototype.toFixed.call("Hello"));
 

test/staging/sm/Number/numericSeparator.js

@@ -11,7 +11,7 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(function() { eval('let a = 100_00_;'); }, SyntaxError);
-assertThrowsInstanceOf(() => eval("let b = 10__;"), SyntaxError);
-assertThrowsInstanceOf(() => eval("let b = 1._2;"), SyntaxError);
+assert.throws(SyntaxError, function() { eval('let a = 100_00_;'); });
+assert.throws(SyntaxError, () => eval("let b = 10__;"));
+assert.throws(SyntaxError, () => eval("let b = 1._2;"));
 

test/staging/sm/WeakMap/symbols.js

@@ -21,7 +21,7 @@ assert.sameValue(m.get(sym), 0);
 // sym1 will be registered in global Symbol registry hence cannot be used as a
 // key in WeakMap.
 var sym1 = Symbol.for("testKey");
-assertThrowsInstanceOf(() => m.set(sym1, 1), TypeError);
+assert.throws(TypeError, () => m.set(sym1, 1));
 
 // Well-known symbols can be used as weakmap keys.
 var sym2 = Symbol.hasInstance;

test/staging/sm/eval/redeclared-arguments-in-param-expression-eval.js

@@ -14,13 +14,13 @@ assert.sameValue("arguments" in this, false);
 
 // Declare |arguments| when no pre-existing (and explicit) |arguments| bindings are present.
 function f1(p = eval("var arguments")) {}
-assertThrowsInstanceOf(f1, SyntaxError);
+assert.throws(SyntaxError, f1);
 
 // Declare |arguments| when the function body contains an |arguments| var-binding.
 function f2(p = eval("var arguments")) {
   var arguments;
 }
-assertThrowsInstanceOf(f2, SyntaxError);
+assert.throws(SyntaxError, f2);
 
 // Declare |arguments| when the function body contains an |arguments| function declaration.
 //
@@ -30,7 +30,7 @@ assertThrowsInstanceOf(f2, SyntaxError);
 function f3(p = eval("var arguments")) {
   function arguments() {}
 }
-assertThrowsInstanceOf(f3, SyntaxError);
+assert.throws(SyntaxError, f3);
 
 // Declare |arguments| when the function body contains an |arguments| lexical binding.
 //
@@ -40,15 +40,15 @@ assertThrowsInstanceOf(f3, SyntaxError);
 function f4(p = eval("var arguments")) {
   let arguments;
 }
-assertThrowsInstanceOf(f4, SyntaxError);
+assert.throws(SyntaxError, f4);
 
 // Declare |arguments| when a following parameter is named |arguments|.
 function f5(p = eval("var arguments"), arguments) {}
-assertThrowsInstanceOf(f5, SyntaxError);
+assert.throws(SyntaxError, f5);
 
 // Declare |arguments| when a preceding parameter is named |arguments|.
 function f6(arguments, p = eval("var arguments")) {}
-assertThrowsInstanceOf(f6, SyntaxError);
+assert.throws(SyntaxError, f6);
 
 
 // Repeat the same kind of tests for arrow function.
@@ -85,11 +85,11 @@ a4();
 
 // Declare |arguments| when a following parameter is named |arguments|.
 var a5 = (p = eval("var arguments"), arguments) => {};
-assertThrowsInstanceOf(a5, SyntaxError);
+assert.throws(SyntaxError, a5);
 
 // Declare |arguments| when a preceding parameter is named |arguments|.
 var a6 = (arguments, p = eval("var arguments")) => {};
-assertThrowsInstanceOf(a6, SyntaxError);
+assert.throws(SyntaxError, a6);
 
 // None of the direct eval calls introduced a global |arguments| binding.
 assert.sameValue("arguments" in this, false);

test/staging/sm/extensions/keyword-unescaped-requirement.js

@@ -39,8 +39,7 @@ var randomExtensions =
 
 for (var extension of randomExtensions)
 {
-  assertThrowsInstanceOf(() => Function(extension), SyntaxError,
-                         "bad behavior for: " + extension);
+  assert.throws(SyntaxError, () => Function(extension), "bad behavior for: " + extension);
 }
 
 /******************************************************************************/

test/staging/sm/extensions/newer-type-functions-caller-arguments.js

@@ -92,12 +92,12 @@ functions.forEach(f => {
 });
 
 function checkArgumentsAccess(f) {
-    assertThrowsInstanceOf(() => f.arguments, TypeError,
-                           `Expected 'arguments' property access to throw on ${f}`);
+    assert.throws(TypeError, () => f.arguments,
+                  `Expected 'arguments' property access to throw on ${f}`);
 }
 
 function checkCallerAccess(f) {
-    assertThrowsInstanceOf(() => f.caller, TypeError,
-                           `Expected 'caller' property access to throw on ${f}`);
+    assert.throws(TypeError, () => f.caller,
+                  `Expected 'caller' property access to throw on ${f}`);
 }
 

test/staging/sm/extensions/shareddataview.js

@@ -36,13 +36,13 @@ assert.sameValue(dv2.getInt8(0), 37);
 
 // Test that range checking works
 
-assertThrowsInstanceOf(() => dv.setInt32(4098, -1), RangeError);
-assertThrowsInstanceOf(() => dv.setInt32(4094, -1), RangeError);
-assertThrowsInstanceOf(() => dv.setInt32(-1, -1), RangeError);
+assert.throws(RangeError, () => dv.setInt32(4098, -1));
+assert.throws(RangeError, () => dv.setInt32(4094, -1));
+assert.throws(RangeError, () => dv.setInt32(-1, -1));
 
-assertThrowsInstanceOf(() => dv2.setInt32(2080, -1), RangeError);
-assertThrowsInstanceOf(() => dv2.setInt32(2046, -1), RangeError);
-assertThrowsInstanceOf(() => dv2.setInt32(-1, -1), RangeError);
+assert.throws(RangeError, () => dv2.setInt32(2080, -1));
+assert.throws(RangeError, () => dv2.setInt32(2046, -1));
+assert.throws(RangeError, () => dv2.setInt32(-1, -1));
 
 }
 

test/staging/sm/fields/unimplemented.js

@@ -26,41 +26,41 @@ if (!fieldsEnabled) {
   let source = `class C {
     x
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     x = 0;
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     0 = 0;
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     [0] = 0;
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     "hi" = 0;
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     "hi" = 0;
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     d = function(){};
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 
   source = `class C {
     d = class D { x = 0; };
   }`;
-  assertThrowsInstanceOf(() => Function(source), SyntaxError);
+  assert.throws(SyntaxError, () => Function(source));
 }
 

test/staging/sm/lexical-environment/unscopables-const.js

@@ -14,5 +14,5 @@ esid: pending
 
 const x = 1;
 with ({x: 1, [Symbol.unscopables]: {x: true}})
-    assertThrowsInstanceOf(() => {x = 2;}, TypeError);
+    assert.throws(TypeError, () => {x = 2;});
 

test/staging/sm/lexical-environment/unscopables-getters.js

@@ -28,7 +28,7 @@ assert.sameValue(hit1, 1);
 // It can throw; the exception is propagated out.
 function Fit() {}
 with ({x: 0, get [Symbol.unscopables]() { throw new Fit; }})
-    assertThrowsInstanceOf(() => x, Fit);
+    assert.throws(Fit, () => x);
 
 // Individual properties on the @@unscopables object can have getters.
 let hit2 = 0;
@@ -47,5 +47,5 @@ assert.sameValue(hit2, 1);
 
 // And they can throw.
 with ({x: 0, [Symbol.unscopables]: {get x() { throw new Fit; }}})
-    assertThrowsInstanceOf(() => x, Fit);
+    assert.throws(Fit, () => x);
 

test/staging/sm/lexical-environment/unscopables-miss.js

@@ -13,5 +13,5 @@ esid: pending
 // is a ReferenceError.
 
 with ({x: 1, [Symbol.unscopables]: {x: true}})
-    assertThrowsInstanceOf(() => x, ReferenceError);
+    assert.throws(ReferenceError, () => x);
 

test/staging/sm/lexical-environment/unscopables-tdz.js

@@ -12,7 +12,7 @@ esid: pending
 // Accessing an uninitialized variable due to @@unscopables is still a ReferenceError.
 
 with ({x: 1, [Symbol.unscopables]: {x: true}})
-    assertThrowsInstanceOf(() => x, ReferenceError);
+    assert.throws(ReferenceError, () => x);
 
 let x;
 

test/staging/sm/literals/numeric/idstart-after-numeric.js

@@ -15,9 +15,9 @@ var BUGNUMBER = '523401';
 var summary = 'numeric literal followed by an identifier';
 
 var array = new Array();
-assertThrowsInstanceOf(() => eval("array[0for]"), SyntaxError);
-assertThrowsInstanceOf(() => eval("array[1yield]"), SyntaxError);
-assertThrowsInstanceOf(() => eval("array[2in []]"), SyntaxError); // "2 in []" is valid.
+assert.throws(SyntaxError, () => eval("array[0for]"));
+assert.throws(SyntaxError, () => eval("array[1yield]"));
+assert.throws(SyntaxError, () => eval("array[2in []]")); // "2 in []" is valid.
 assert.sameValue(array[2 in []], undefined);
 assert.sameValue(2 in [], false);
-assertThrowsInstanceOf(() => eval("array[3in]"), SyntaxError);
+assert.throws(SyntaxError, () => eval("array[3in]"));

test/staging/sm/regress/regress-640075.js

@@ -12,8 +12,8 @@ description: |
 esid: pending
 ---*/
 "use strict";
-assertThrowsInstanceOf(
-    () => eval("(function() { eval(); function eval() {} })"),
-    SyntaxError
+assert.throws(
+    SyntaxError,
+    () => eval("(function() { eval(); function eval() {} })")
 )
 

test/staging/sm/strict/primitive-assignment.js

@@ -23,8 +23,8 @@ for (let value of primitives) {
     assert.sameValue(value.x = 5, 5);
     assert.sameValue(value[key] = 6, 6);
 
-    assertThrowsInstanceOf(function() { "use strict"; value.x = 5; }, TypeError);
-    assertThrowsInstanceOf(function() { "use strict"; value[key] = 6; }, TypeError);
+    assert.throws(TypeError, function() { "use strict"; value.x = 5; });
+    assert.throws(TypeError, function() { "use strict"; value[key] = 6; });
 
     let target = {};
     assert.sameValue(Reflect.set(target, key, 5, value), false);