Rename parseClassMethod to pushClassMethod

This makes it consistent to the equivalent method for class properties,
as well as the private version (parseClassPrivateMethod).

This commit also removes one of the tests from the Test262 whitelist.

scripts/test262_whitelist.txt

@@ -256,8 +256,6 @@ language/statements/class/definition/early-errors-class-method-await-in-formals.
 language/statements/class/strict-mode/with.js(default)
 language/statements/class/syntax/early-errors/class-body-has-direct-super-missing-class-heritage.js(default)
 language/statements/class/syntax/early-errors/class-body-has-direct-super-missing-class-heritage.js(strict mode)
-language/statements/class/syntax/early-errors/class-body-static-method-get-propname-prototype.js(default)
-language/statements/class/syntax/early-errors/class-body-static-method-get-propname-prototype.js(strict mode)
 language/statements/class/syntax/early-errors/class-definition-evaluation-block-duplicate-binding.js(default)
 language/statements/class/syntax/early-errors/class-definition-evaluation-block-duplicate-binding.js(strict mode)
 language/statements/class/syntax/early-errors/class-definition-evaluation-scriptbody-duplicate-binding.js(default)
@@ -1305,4 +1303,4 @@ language/statements/class/fields-wrapped-in-sc-string-literal-names.js(strict mo
 
 language/statements/labeled/let-identifier-with-newline.js(default)
 language/statements/labeled/value-yield-non-strict-escaped.js(default)
-language/statements/let/syntax/escaped-let.js(default)
+language/statements/let/syntax/escaped-let.js(default)

src/parser/expression.js

@@ -1411,12 +1411,12 @@ export default class ExpressionParser extends LValParser {
     } else {
       const oldInPropertyName = this.state.inPropertyName;
       this.state.inPropertyName = true;
+      // We check if it's valid for it to be a private name when we push it.
       prop.key =
         this.match(tt.num) || this.match(tt.string)
           ? this.parseExprAtom()
           : this.parseMaybePrivateName();
 
-      // TODO: if no plugin and is PrivateName, should error be handled here or elsewhere?
       if (prop.key.type !== "PrivateName") {
         // ClassPrivateProperty is never computed, so we don't assign in that case.
         prop.computed = false;

src/parser/statement.js

@@ -935,7 +935,7 @@ export default class StatementParser extends ExpressionParser {
         method.computed = false;
         method.key = key;
         method.static = false;
-        this.parseClassMethod(
+        this.pushClassMethod(
           classBody,
           method,
           false,
@@ -982,15 +982,15 @@ export default class StatementParser extends ExpressionParser {
 
       if (method.key.type === "PrivateName") {
         // Private generator method
-        this.parseClassPrivateMethod(classBody, method, true, false);
+        this.pushClassPrivateMethod(classBody, method, true, false);
         return;
       }
 
       if (this.isNonstaticConstructor(method)) {
         this.raise(method.key.start, "Constructor can't be a generator");
       }
 
-      this.parseClassMethod(
+      this.pushClassMethod(
         classBody,
         method,
         true,
@@ -1004,7 +1004,7 @@ export default class StatementParser extends ExpressionParser {
     const key = this.parseClassPropertyName(methodOrProp);
     const isPrivate = key.type === "PrivateName";
     // Check the key is not a computed expression or string literal.
-    const isSimple = key.type === 'Identifier';
+    const isSimple = key.type === "Identifier";
 
     // TODO: should these be merged into pushClassProperty?
     const handleClassProperty = () => {
@@ -1021,7 +1021,7 @@ export default class StatementParser extends ExpressionParser {
       method.kind = "method";
 
       if (isPrivate) {
-        this.parseClassPrivateMethod(classBody, method, false, false);
+        this.pushClassPrivateMethod(classBody, method, false, false);
         return;
       }
 
@@ -1045,7 +1045,7 @@ export default class StatementParser extends ExpressionParser {
         state.hadConstructor = true;
       }
 
-      this.parseClassMethod(classBody, method, false, false, isConstructor);
+      this.pushClassMethod(classBody, method, false, false, isConstructor);
     } else if (this.isClassProperty()) {
       handleClassProperty();
     } else if (isSimple && key.name === "async" && !this.isLineTerminator()) {
@@ -1062,7 +1062,7 @@ export default class StatementParser extends ExpressionParser {
 
       if (method.key.type === "PrivateName") {
         // private async method
-        this.parseClassPrivateMethod(classBody, method, isGenerator, true);
+        this.pushClassPrivateMethod(classBody, method, isGenerator, true);
       } else {
         if (this.isNonstaticConstructor(method)) {
           this.raise(
@@ -1071,7 +1071,7 @@ export default class StatementParser extends ExpressionParser {
           );
         }
 
-        this.parseClassMethod(
+        this.pushClassMethod(
           classBody,
           method,
           isGenerator,
@@ -1092,15 +1092,15 @@ export default class StatementParser extends ExpressionParser {
 
       if (method.key.type === "PrivateName") {
         // private getter/setter
-        this.parseClassPrivateMethod(classBody, method, false, false);
+        this.pushClassPrivateMethod(classBody, method, false, false);
       } else {
         if (this.isNonstaticConstructor(method)) {
           this.raise(
             method.key.start,
             "Constructor can't have get/set modifier",
           );
         }
-        this.parseClassMethod(
+        this.pushClassMethod(
           classBody,
           method,
           false,
@@ -1161,6 +1161,42 @@ export default class StatementParser extends ExpressionParser {
     classBody.body.push(this.parseClassPrivateProperty(prop));
   }
 
+  pushClassMethod(
+    classBody: N.ClassBody,
+    method: N.ClassMethod,
+    isGenerator: boolean,
+    isAsync: boolean,
+    isConstructor: boolean,
+  ): void {
+    classBody.body.push(
+      this.parseMethod(
+        method,
+        isGenerator,
+        isAsync,
+        isConstructor,
+        "ClassMethod",
+      ),
+    );
+  }
+
+  pushClassPrivateMethod(
+    classBody: N.ClassBody,
+    method: N.ClassMethod,
+    isGenerator: boolean,
+    isAsync: boolean,
+  ): void {
+    this.expectPlugin("classPrivateMethods", method.key.start);
+    classBody.body.push(
+      this.parseMethod(
+        method,
+        isGenerator,
+        isAsync,
+        /* isConstructor */ false,
+        "ClassPrivateMethod",
+      ),
+    );
+  }
+
   // Overridden in typescript.js
   parsePostMemberNameModifiers(
     // eslint-disable-next-line no-unused-vars
@@ -1202,42 +1238,6 @@ export default class StatementParser extends ExpressionParser {
     return this.finishNode(node, "ClassProperty");
   }
 
-  parseClassMethod(
-    classBody: N.ClassBody,
-    method: N.ClassMethod,
-    isGenerator: boolean,
-    isAsync: boolean,
-    isConstructor: boolean,
-  ): void {
-    classBody.body.push(
-      this.parseMethod(
-        method,
-        isGenerator,
-        isAsync,
-        isConstructor,
-        "ClassMethod",
-      ),
-    );
-  }
-
-  parseClassPrivateMethod(
-    classBody: N.ClassBody,
-    method: N.ClassMethod,
-    isGenerator: boolean,
-    isAsync: boolean,
-  ): void {
-    this.expectPlugin("classPrivateMethods", method.key.start);
-    classBody.body.push(
-      this.parseMethod(
-        method,
-        isGenerator,
-        isAsync,
-        /* isConstructor */ false,
-        "ClassPrivateMethod",
-      ),
-    );
-  }
-
   parseClassId(
     node: N.Class,
     isStatement: boolean,

src/plugins/estree.js

@@ -183,7 +183,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       delete node.directives;
     }
 
-    parseClassMethod(
+    pushClassMethod(
       classBody: N.ClassBody,
       method: N.ClassMethod,
       isGenerator: boolean,

src/plugins/flow.js

@@ -1526,7 +1526,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     // parse type parameters for class methods
-    parseClassMethod(
+    pushClassMethod(
       classBody: N.ClassBody,
       method: N.ClassMethod,
       isGenerator: boolean,
@@ -1541,7 +1541,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         method.typeParameters = this.flowParseTypeParameterDeclaration();
       }
 
-      super.parseClassMethod(
+      super.pushClassMethod(
         classBody,
         method,
         isGenerator,
@@ -1550,6 +1550,23 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       );
     }
 
+    pushClassPrivateMethod(
+      classBody: N.ClassBody,
+      method: N.ClassPrivateMethod,
+      isGenerator: boolean,
+      isAsync: boolean,
+    ): void {
+      if (method.variance) {
+        this.unexpected(method.variance.start);
+      }
+      delete method.variance;
+      if (this.isRelational("<")) {
+        method.typeParameters = this.flowParseTypeParameterDeclaration();
+      }
+
+      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
+    }
+
     // parse a the super class type parameters and implements
     parseClassSuper(node: N.Class): void {
       super.parseClassSuper(node);

src/plugins/typescript.js

@@ -1639,7 +1639,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return super.parseClassProperty(node);
     }
 
-    parseClassMethod(
+    pushClassMethod(
       classBody: N.ClassBody,
       method: N.ClassMethod,
       isGenerator: boolean,
@@ -1648,7 +1648,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     ): void {
       const typeParameters = this.tsTryParseTypeParameters();
       if (typeParameters) method.typeParameters = typeParameters;
-      super.parseClassMethod(
+      super.pushClassMethod(
         classBody,
         method,
         isGenerator,
@@ -1657,6 +1657,17 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       );
     }
 
+    pushClassPrivateMethod(
+      classBody: N.ClassBody,
+      method: N.ClassPrivateMethod,
+      isGenerator: boolean,
+      isAsync: boolean,
+    ): void {
+      const typeParameters = this.tsTryParseTypeParameters();
+      if (typeParameters) method.typeParameters = typeParameters;
+      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
+    }
+
     parseClassSuper(node: N.Class): void {
       super.parseClassSuper(node);
       if (node.superClass && this.isRelational("<")) {