Replace assertThrowsInstanceOf with assert.throws in sm/PrivateName

test/staging/sm/PrivateName/error-outside-class.js

@@ -11,13 +11,12 @@ esid: pending
 ---*/
 
 // Can't reference a private field without an object
-assertThrowsInstanceOf(() => eval('#x'), SyntaxError);
+assert.throws(SyntaxError, () => eval('#x'));
 
 // Can't reference a private field without an enclosing class
-assertThrowsInstanceOf(() => eval('this.#x'), SyntaxError);
+assert.throws(SyntaxError, () => eval('this.#x'));
 
 // Can't reference a private field in a random function outside a class context
-assertThrowsInstanceOf(
+assert.throws(SyntaxError, () => eval('function foo() { return this.#x'));
-    () => eval('function foo() { return this.#x'), SyntaxError);
 
 

test/staging/sm/PrivateName/illegal-in-class-context.js

@@ -10,11 +10,10 @@ description: |
 esid: pending
 ---*/
 
-assertThrowsInstanceOf(() => eval(`class A { #x; #x; }`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`class A { #x; #x; }`));
 
 // No computed private fields
-assertThrowsInstanceOf(
+assert.throws(SyntaxError, () => eval(`var x = "foo"; class A { #[x] = 20; }`));
-    () => eval(`var x = "foo"; class A { #[x] = 20; }`), SyntaxError);
 
 assert.throws(
     SyntaxError,

test/staging/sm/PrivateName/illegal-in-identifier-context.js

@@ -13,41 +13,41 @@ esid: pending
 // Private names can't appear in contexts where plain identifiers are expected.
 
 // Private names as binding identifiers.
-assertThrowsInstanceOf(() => eval(`var #a;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var #a;`));
-assertThrowsInstanceOf(() => eval(`let #a;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`let #a;`));
-assertThrowsInstanceOf(() => eval(`const #a = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`const #a = 0;`));
-assertThrowsInstanceOf(() => eval(`function #a(){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`function #a(){}`));
-assertThrowsInstanceOf(() => eval(`function f(#a){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`function f(#a){}`));
 
 // With escape sequences (leading and non-leading case).
-assertThrowsInstanceOf(() => eval(String.raw`var #\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`var #\u0061;`));
-assertThrowsInstanceOf(() => eval(String.raw`var #a\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`var #a\u0061;`));
-assertThrowsInstanceOf(() => eval(String.raw`let #\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`let #\u0061;`));
-assertThrowsInstanceOf(() => eval(String.raw`let #a\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`let #a\u0061;`));
-assertThrowsInstanceOf(() => eval(String.raw`const #\u0061 = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`const #\u0061 = 0;`));
-assertThrowsInstanceOf(() => eval(String.raw`const #a\u0061 = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`const #a\u0061 = 0;`));
-assertThrowsInstanceOf(() => eval(String.raw`function #\u0061(){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`function #\u0061(){}`));
-assertThrowsInstanceOf(() => eval(String.raw`function #a\u0061(){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`function #a\u0061(){}`));
-assertThrowsInstanceOf(() => eval(String.raw`function f(#\u0061){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`function f(#\u0061){}`));
-assertThrowsInstanceOf(() => eval(String.raw`function f(#a\u0061){}`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`function f(#a\u0061){}`));
 
 
 // Private names as label identifiers.
-assertThrowsInstanceOf(() => eval(`#a: ;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`#a: ;`));
 
 // With escape sequences (leading and non-leading case).
-assertThrowsInstanceOf(() => eval(String.raw`#\u0061: ;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`#\u0061: ;`));
-assertThrowsInstanceOf(() => eval(String.raw`#a\u0061: ;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`#a\u0061: ;`));
 
 
 // Private names as identifier references.
-assertThrowsInstanceOf(() => eval(`#a = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`#a = 0;`));
-assertThrowsInstanceOf(() => eval(`typeof #a;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`typeof #a;`));
 
 // With escape sequences (leading and non-leading case).
-assertThrowsInstanceOf(() => eval(String.raw`#\u0061 = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`#\u0061 = 0;`));
-assertThrowsInstanceOf(() => eval(String.raw`#a\u0061 = 0;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`#a\u0061 = 0;`));
-assertThrowsInstanceOf(() => eval(String.raw`typeof #\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`typeof #\u0061;`));
-assertThrowsInstanceOf(() => eval(String.raw`typeof #a\u0061;`), SyntaxError);
+assert.throws(SyntaxError, () => eval(String.raw`typeof #a\u0061;`));
 
 

test/staging/sm/PrivateName/illegal-in-object-context.js

@@ -12,12 +12,12 @@ esid: pending
 
 // Private names aren't valid in object literals.
 
-assertThrowsInstanceOf(() => eval(`var o = {#a: 0};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {#a: 0};`));
-assertThrowsInstanceOf(() => eval(`var o = {#a};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {#a};`));
-assertThrowsInstanceOf(() => eval(`var o = {#a(){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {#a(){}};`));
-assertThrowsInstanceOf(() => eval(`var o = {get #a(){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {get #a(){}};`));
-assertThrowsInstanceOf(() => eval(`var o = {set #a(v){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {set #a(v){}};`));
-assertThrowsInstanceOf(() => eval(`var o = {*#a(v){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {*#a(v){}};`));
-assertThrowsInstanceOf(() => eval(`var o = {async #a(v){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {async #a(v){}};`));
-assertThrowsInstanceOf(() => eval(`var o = {async *#a(v){}};`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`var o = {async *#a(v){}};`));
 

test/staging/sm/PrivateName/lexical-presence.js

@@ -16,9 +16,9 @@ class A {
 };
 
 function assertThrowsSyntaxError(str) {
-  assertThrowsInstanceOf(() => eval(str), SyntaxError);       // Direct Eval
+  assert.throws(SyntaxError, () => eval(str));       // Direct Eval
-  assertThrowsInstanceOf(() => (1, eval)(str), SyntaxError);  // Indirect Eval
+  assert.throws(SyntaxError, () => (1, eval)(str));  // Indirect Eval
-  assertThrowsInstanceOf(() => Function(str), SyntaxError);   // Function
+  assert.throws(SyntaxError, () => Function(str));   // Function
 }
 
 assertThrowsSyntaxError(`
@@ -55,7 +55,7 @@ function assertNonExisting(fetchCode) {
   }
   var a = new X;
   a.b()`
-  assertThrowsInstanceOf(() => eval(source), SyntaxError);
+  assert.throws(SyntaxError, () => eval(source));
 }
 
 assertNonExisting(`return eval("this.#x")"`);