Bug 1403556 - Remove PNK prefixes. r=jandem
authorRofael Aleezada <me@rofael.com>
Thu, 28 Dec 2017 19:10:00 -0500
changeset 449283 e5c3eb27d1b4ddb38ea82cd6838e564aebe8c3f7
parent 449282 df5abacfb68c1c7ce6c897b30bee99190b5c99b4
child 449284 522e9e2a6c829e170e280ad920385de3b38487c3
push id8527
push userCallek@gmail.com
push dateThu, 11 Jan 2018 21:05:50 +0000
treeherdermozilla-beta@95342d212a7a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1403556
milestone59.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1403556 - Remove PNK prefixes. r=jandem
js/src/builtin/ModuleObject.cpp
js/src/builtin/ReflectParse.cpp
js/src/frontend/BinSource.cpp
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/FoldConstants.cpp
js/src/frontend/FullParseHandler.h
js/src/frontend/NameFunctions.cpp
js/src/frontend/ParseNode-inl.h
js/src/frontend/ParseNode.cpp
js/src/frontend/ParseNode.h
js/src/frontend/Parser.cpp
js/src/frontend/SyntaxParseHandler.h
js/src/wasm/AsmJS.cpp
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -1298,27 +1298,27 @@ ModuleBuilder::initModule()
                                  starExportEntries);
 
     return true;
 }
 
 bool
 ModuleBuilder::processImport(frontend::ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_IMPORT));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Import));
     MOZ_ASSERT(pn->isArity(PN_BINARY));
-    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_IMPORT_SPEC_LIST));
-    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::ImportSpecList));
+    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::String));
 
     RootedAtom module(cx_, pn->pn_right->pn_atom);
     if (!maybeAppendRequestedModule(module, pn->pn_right))
         return false;
 
     for (ParseNode* spec = pn->pn_left->pn_head; spec; spec = spec->pn_next) {
-        MOZ_ASSERT(spec->isKind(ParseNodeKind::PNK_IMPORT_SPEC));
+        MOZ_ASSERT(spec->isKind(ParseNodeKind::ImportSpec));
         MOZ_ASSERT(spec->pn_left->isArity(PN_NAME));
         MOZ_ASSERT(spec->pn_right->isArity(PN_NAME));
 
         RootedAtom importName(cx_, spec->pn_left->pn_atom);
         RootedAtom localName(cx_, spec->pn_right->pn_atom);
 
         if (!importedBoundNames_.append(localName))
             return false;
@@ -1334,68 +1334,68 @@ ModuleBuilder::processImport(frontend::P
     }
 
     return true;
 }
 
 bool
 ModuleBuilder::processExport(frontend::ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_EXPORT) || pn->isKind(ParseNodeKind::PNK_EXPORT_DEFAULT));
-    MOZ_ASSERT(pn->getArity() == (pn->isKind(ParseNodeKind::PNK_EXPORT) ? PN_UNARY : PN_BINARY));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Export) || pn->isKind(ParseNodeKind::ExportDefault));
+    MOZ_ASSERT(pn->getArity() == (pn->isKind(ParseNodeKind::Export) ? PN_UNARY : PN_BINARY));
 
-    bool isDefault = pn->getKind() == ParseNodeKind::PNK_EXPORT_DEFAULT;
+    bool isDefault = pn->getKind() == ParseNodeKind::ExportDefault;
     ParseNode* kid = isDefault ? pn->pn_left : pn->pn_kid;
 
     if (isDefault && pn->pn_right) {
         // This is an export default containing an expression.
         HandlePropertyName localName = cx_->names().default_;
         HandlePropertyName exportName = cx_->names().default_;
         return appendExportEntry(exportName, localName);
     }
 
     switch (kid->getKind()) {
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
+      case ParseNodeKind::ExportSpecList:
         MOZ_ASSERT(!isDefault);
         for (ParseNode* spec = kid->pn_head; spec; spec = spec->pn_next) {
-            MOZ_ASSERT(spec->isKind(ParseNodeKind::PNK_EXPORT_SPEC));
+            MOZ_ASSERT(spec->isKind(ParseNodeKind::ExportSpec));
             RootedAtom localName(cx_, spec->pn_left->pn_atom);
             RootedAtom exportName(cx_, spec->pn_right->pn_atom);
             if (!appendExportEntry(exportName, localName, spec))
                 return false;
         }
         break;
 
-      case ParseNodeKind::PNK_CLASS: {
+      case ParseNodeKind::Class: {
         const ClassNode& cls = kid->as<ClassNode>();
         MOZ_ASSERT(cls.names());
         RootedAtom localName(cx_, cls.names()->innerBinding()->pn_atom);
         RootedAtom exportName(cx_, isDefault ? cx_->names().default_ : localName.get());
         if (!appendExportEntry(exportName, localName))
             return false;
         break;
       }
 
-      case ParseNodeKind::PNK_VAR:
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET: {
+      case ParseNodeKind::Var:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let: {
         MOZ_ASSERT(kid->isArity(PN_LIST));
         for (ParseNode* var = kid->pn_head; var; var = var->pn_next) {
-            if (var->isKind(ParseNodeKind::PNK_ASSIGN))
+            if (var->isKind(ParseNodeKind::Assign))
                 var = var->pn_left;
-            MOZ_ASSERT(var->isKind(ParseNodeKind::PNK_NAME));
+            MOZ_ASSERT(var->isKind(ParseNodeKind::Name));
             RootedAtom localName(cx_, var->pn_atom);
             RootedAtom exportName(cx_, isDefault ? cx_->names().default_ : localName.get());
             if (!appendExportEntry(exportName, localName))
                 return false;
         }
         break;
       }
 
-      case ParseNodeKind::PNK_FUNCTION: {
+      case ParseNodeKind::Function: {
         RootedFunction func(cx_, kid->pn_funbox->function());
         MOZ_ASSERT(!func->isArrow());
         RootedAtom localName(cx_, func->explicitName());
         RootedAtom exportName(cx_, isDefault ? cx_->names().default_ : localName.get());
         MOZ_ASSERT_IF(isDefault, localName);
         if (!appendExportEntry(exportName, localName))
             return false;
         break;
@@ -1406,33 +1406,33 @@ ModuleBuilder::processExport(frontend::P
     }
 
     return true;
 }
 
 bool
 ModuleBuilder::processExportFrom(frontend::ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_EXPORT_FROM));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::ExportFrom));
     MOZ_ASSERT(pn->isArity(PN_BINARY));
-    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_EXPORT_SPEC_LIST));
-    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::ExportSpecList));
+    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::String));
 
     RootedAtom module(cx_, pn->pn_right->pn_atom);
     if (!maybeAppendRequestedModule(module, pn->pn_right))
         return false;
 
     for (ParseNode* spec = pn->pn_left->pn_head; spec; spec = spec->pn_next) {
-        if (spec->isKind(ParseNodeKind::PNK_EXPORT_SPEC)) {
+        if (spec->isKind(ParseNodeKind::ExportSpec)) {
             RootedAtom bindingName(cx_, spec->pn_left->pn_atom);
             RootedAtom exportName(cx_, spec->pn_right->pn_atom);
             if (!appendExportFromEntry(exportName, module, bindingName, spec->pn_left))
                 return false;
         } else {
-            MOZ_ASSERT(spec->isKind(ParseNodeKind::PNK_EXPORT_BATCH_SPEC));
+            MOZ_ASSERT(spec->isKind(ParseNodeKind::ExportBatchSpec));
             RootedAtom importName(cx_, cx_->names().star);
             if (!appendExportFromEntry(nullptr, module, importName, spec))
                 return false;
         }
     }
 
     return true;
 }
--- a/js/src/builtin/ReflectParse.cpp
+++ b/js/src/builtin/ReflectParse.cpp
@@ -1744,133 +1744,133 @@ class ASTSerializer
 };
 
 } /* anonymous namespace */
 
 AssignmentOperator
 ASTSerializer::aop(ParseNodeKind kind)
 {
     switch (kind) {
-      case ParseNodeKind::PNK_ASSIGN:
+      case ParseNodeKind::Assign:
         return AOP_ASSIGN;
-      case ParseNodeKind::PNK_ADDASSIGN:
+      case ParseNodeKind::AddAssign:
         return AOP_PLUS;
-      case ParseNodeKind::PNK_SUBASSIGN:
+      case ParseNodeKind::SubAssign:
         return AOP_MINUS;
-      case ParseNodeKind::PNK_MULASSIGN:
+      case ParseNodeKind::MulAssign:
         return AOP_STAR;
-      case ParseNodeKind::PNK_DIVASSIGN:
+      case ParseNodeKind::DivAssign:
         return AOP_DIV;
-      case ParseNodeKind::PNK_MODASSIGN:
+      case ParseNodeKind::ModAssign:
         return AOP_MOD;
-      case ParseNodeKind::PNK_POWASSIGN:
+      case ParseNodeKind::PowAssign:
         return AOP_POW;
-      case ParseNodeKind::PNK_LSHASSIGN:
+      case ParseNodeKind::LshAssign:
         return AOP_LSH;
-      case ParseNodeKind::PNK_RSHASSIGN:
+      case ParseNodeKind::RshAssign:
         return AOP_RSH;
-      case ParseNodeKind::PNK_URSHASSIGN:
+      case ParseNodeKind::UrshAssign:
         return AOP_URSH;
-      case ParseNodeKind::PNK_BITORASSIGN:
+      case ParseNodeKind::BitOrAssign:
         return AOP_BITOR;
-      case ParseNodeKind::PNK_BITXORASSIGN:
+      case ParseNodeKind::BitXorAssign:
         return AOP_BITXOR;
-      case ParseNodeKind::PNK_BITANDASSIGN:
+      case ParseNodeKind::BitAndAssign:
         return AOP_BITAND;
       default:
         return AOP_ERR;
     }
 }
 
 UnaryOperator
 ASTSerializer::unop(ParseNodeKind kind)
 {
     if (IsDeleteKind(kind))
         return UNOP_DELETE;
 
     if (IsTypeofKind(kind))
         return UNOP_TYPEOF;
 
     switch (kind) {
-      case ParseNodeKind::PNK_AWAIT:
+      case ParseNodeKind::Await:
         return UNOP_AWAIT;
-      case ParseNodeKind::PNK_NEG:
+      case ParseNodeKind::Neg:
         return UNOP_NEG;
-      case ParseNodeKind::PNK_POS:
+      case ParseNodeKind::Pos:
         return UNOP_POS;
-      case ParseNodeKind::PNK_NOT:
+      case ParseNodeKind::Not:
         return UNOP_NOT;
-      case ParseNodeKind::PNK_BITNOT:
+      case ParseNodeKind::BitNot:
         return UNOP_BITNOT;
-      case ParseNodeKind::PNK_VOID:
+      case ParseNodeKind::Void:
         return UNOP_VOID;
       default:
         return UNOP_ERR;
     }
 }
 
 BinaryOperator
 ASTSerializer::binop(ParseNodeKind kind)
 {
     switch (kind) {
-      case ParseNodeKind::PNK_LSH:
+      case ParseNodeKind::Lsh:
         return BINOP_LSH;
-      case ParseNodeKind::PNK_RSH:
+      case ParseNodeKind::Rsh:
         return BINOP_RSH;
-      case ParseNodeKind::PNK_URSH:
+      case ParseNodeKind::Ursh:
         return BINOP_URSH;
-      case ParseNodeKind::PNK_LT:
+      case ParseNodeKind::Lt:
         return BINOP_LT;
-      case ParseNodeKind::PNK_LE:
+      case ParseNodeKind::Le:
         return BINOP_LE;
-      case ParseNodeKind::PNK_GT:
+      case ParseNodeKind::Gt:
         return BINOP_GT;
-      case ParseNodeKind::PNK_GE:
+      case ParseNodeKind::Ge:
         return BINOP_GE;
-      case ParseNodeKind::PNK_EQ:
+      case ParseNodeKind::Eq:
         return BINOP_EQ;
-      case ParseNodeKind::PNK_NE:
+      case ParseNodeKind::Ne:
         return BINOP_NE;
-      case ParseNodeKind::PNK_STRICTEQ:
+      case ParseNodeKind::StrictEq:
         return BINOP_STRICTEQ;
-      case ParseNodeKind::PNK_STRICTNE:
+      case ParseNodeKind::StrictNe:
         return BINOP_STRICTNE;
-      case ParseNodeKind::PNK_ADD:
+      case ParseNodeKind::Add:
         return BINOP_ADD;
-      case ParseNodeKind::PNK_SUB:
+      case ParseNodeKind::Sub:
         return BINOP_SUB;
-      case ParseNodeKind::PNK_STAR:
+      case ParseNodeKind::Star:
         return BINOP_STAR;
-      case ParseNodeKind::PNK_DIV:
+      case ParseNodeKind::Div:
         return BINOP_DIV;
-      case ParseNodeKind::PNK_MOD:
+      case ParseNodeKind::Mod:
         return BINOP_MOD;
-      case ParseNodeKind::PNK_POW:
+      case ParseNodeKind::Pow:
         return BINOP_POW;
-      case ParseNodeKind::PNK_BITOR:
+      case ParseNodeKind::BitOr:
         return BINOP_BITOR;
-      case ParseNodeKind::PNK_BITXOR:
+      case ParseNodeKind::BitXor:
         return BINOP_BITXOR;
-      case ParseNodeKind::PNK_BITAND:
+      case ParseNodeKind::BitAnd:
         return BINOP_BITAND;
-      case ParseNodeKind::PNK_IN:
+      case ParseNodeKind::In:
         return BINOP_IN;
-      case ParseNodeKind::PNK_INSTANCEOF:
+      case ParseNodeKind::InstanceOf:
         return BINOP_INSTANCEOF;
-      case ParseNodeKind::PNK_PIPELINE:
+      case ParseNodeKind::Pipeline:
         return BINOP_PIPELINE;
       default:
         return BINOP_ERR;
     }
 }
 
 bool
 ASTSerializer::statements(ParseNode* pn, NodeVector& elts)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::StatementList));
     MOZ_ASSERT(pn->isArity(PN_LIST));
 
     if (!elts.reserve(pn->pn_count))
         return false;
 
     for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
         MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
@@ -1899,17 +1899,17 @@ ASTSerializer::expressions(ParseNode* pn
     }
 
     return true;
 }
 
 bool
 ASTSerializer::blockStatement(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::StatementList));
 
     NodeVector stmts(cx);
     return statements(pn, stmts) &&
            builder.blockStatement(stmts, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::program(ParseNode* pn, MutableHandleValue dst)
@@ -1926,47 +1926,47 @@ ASTSerializer::sourceElement(ParseNode* 
 {
     /* SpiderMonkey allows declarations even in pure statement contexts. */
     return statement(pn, dst);
 }
 
 bool
 ASTSerializer::declaration(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_FUNCTION) ||
-               pn->isKind(ParseNodeKind::PNK_VAR) ||
-               pn->isKind(ParseNodeKind::PNK_LET) ||
-               pn->isKind(ParseNodeKind::PNK_CONST));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Function) ||
+               pn->isKind(ParseNodeKind::Var) ||
+               pn->isKind(ParseNodeKind::Let) ||
+               pn->isKind(ParseNodeKind::Const));
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         return function(pn, AST_FUNC_DECL, dst);
 
-      case ParseNodeKind::PNK_VAR:
+      case ParseNodeKind::Var:
         return variableDeclaration(pn, false, dst);
 
       default:
-        MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_LET) || pn->isKind(ParseNodeKind::PNK_CONST));
+        MOZ_ASSERT(pn->isKind(ParseNodeKind::Let) || pn->isKind(ParseNodeKind::Const));
         return variableDeclaration(pn, true, dst);
     }
 }
 
 bool
 ASTSerializer::variableDeclaration(ParseNode* pn, bool lexical, MutableHandleValue dst)
 {
-    MOZ_ASSERT_IF(lexical, pn->isKind(ParseNodeKind::PNK_LET) || pn->isKind(ParseNodeKind::PNK_CONST));
-    MOZ_ASSERT_IF(!lexical, pn->isKind(ParseNodeKind::PNK_VAR));
+    MOZ_ASSERT_IF(lexical, pn->isKind(ParseNodeKind::Let) || pn->isKind(ParseNodeKind::Const));
+    MOZ_ASSERT_IF(!lexical, pn->isKind(ParseNodeKind::Var));
 
     VarDeclKind kind = VARDECL_ERR;
     // Treat both the toplevel const binding (secretly var-like) and the lexical const
     // the same way
     if (lexical)
-        kind = pn->isKind(ParseNodeKind::PNK_LET) ? VARDECL_LET : VARDECL_CONST;
+        kind = pn->isKind(ParseNodeKind::Let) ? VARDECL_LET : VARDECL_CONST;
     else
-        kind = pn->isKind(ParseNodeKind::PNK_VAR) ? VARDECL_VAR : VARDECL_CONST;
+        kind = pn->isKind(ParseNodeKind::Var) ? VARDECL_VAR : VARDECL_CONST;
 
     NodeVector dtors(cx);
     if (!dtors.reserve(pn->pn_count))
         return false;
     for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
         RootedValue child(cx);
         if (!variableDeclarator(next, &child))
             return false;
@@ -1976,21 +1976,21 @@ ASTSerializer::variableDeclaration(Parse
 }
 
 bool
 ASTSerializer::variableDeclarator(ParseNode* pn, MutableHandleValue dst)
 {
     ParseNode* pnleft;
     ParseNode* pnright;
 
-    if (pn->isKind(ParseNodeKind::PNK_NAME)) {
+    if (pn->isKind(ParseNodeKind::Name)) {
         pnleft = pn;
         pnright = pn->pn_expr;
         MOZ_ASSERT_IF(pnright, pn->pn_pos.encloses(pnright->pn_pos));
-    } else if (pn->isKind(ParseNodeKind::PNK_ASSIGN)) {
+    } else if (pn->isKind(ParseNodeKind::Assign)) {
         pnleft = pn->pn_left;
         pnright = pn->pn_right;
         MOZ_ASSERT(pn->pn_pos.encloses(pnleft->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pnright->pn_pos));
     } else {
         /* This happens for a destructuring declarator in a for-in/of loop. */
         pnleft = pn;
         pnright = nullptr;
@@ -2000,20 +2000,20 @@ ASTSerializer::variableDeclarator(ParseN
     return pattern(pnleft, &left) &&
            optExpression(pnright, &right) &&
            builder.variableDeclarator(left, right, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::importDeclaration(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_IMPORT));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Import));
     MOZ_ASSERT(pn->isArity(PN_BINARY));
-    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_IMPORT_SPEC_LIST));
-    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::ImportSpecList));
+    MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::String));
 
     NodeVector elts(cx);
     if (!elts.reserve(pn->pn_left->pn_count))
         return false;
 
     for (ParseNode* next = pn->pn_left->pn_head; next; next = next->pn_next) {
         RootedValue elt(cx);
         if (!importSpecifier(next, &elt))
@@ -2024,94 +2024,94 @@ ASTSerializer::importDeclaration(ParseNo
     RootedValue moduleSpec(cx);
     return literal(pn->pn_right, &moduleSpec) &&
            builder.importDeclaration(elts, moduleSpec, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::importSpecifier(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_IMPORT_SPEC));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::ImportSpec));
 
     RootedValue importName(cx);
     RootedValue bindingName(cx);
     return identifier(pn->pn_left, &importName) &&
            identifier(pn->pn_right, &bindingName) &&
            builder.importSpecifier(importName, bindingName, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::exportDeclaration(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_EXPORT) ||
-               pn->isKind(ParseNodeKind::PNK_EXPORT_FROM) ||
-               pn->isKind(ParseNodeKind::PNK_EXPORT_DEFAULT));
-    MOZ_ASSERT(pn->getArity() == (pn->isKind(ParseNodeKind::PNK_EXPORT) ? PN_UNARY : PN_BINARY));
-    MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::PNK_EXPORT_FROM), pn->pn_right->isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Export) ||
+               pn->isKind(ParseNodeKind::ExportFrom) ||
+               pn->isKind(ParseNodeKind::ExportDefault));
+    MOZ_ASSERT(pn->getArity() == (pn->isKind(ParseNodeKind::Export) ? PN_UNARY : PN_BINARY));
+    MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::ExportFrom), pn->pn_right->isKind(ParseNodeKind::String));
 
     RootedValue decl(cx, NullValue());
     NodeVector elts(cx);
 
-    ParseNode* kid = pn->isKind(ParseNodeKind::PNK_EXPORT) ? pn->pn_kid : pn->pn_left;
+    ParseNode* kid = pn->isKind(ParseNodeKind::Export) ? pn->pn_kid : pn->pn_left;
     switch (ParseNodeKind kind = kid->getKind()) {
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
+      case ParseNodeKind::ExportSpecList:
         if (!elts.reserve(pn->pn_left->pn_count))
             return false;
 
         for (ParseNode* next = pn->pn_left->pn_head; next; next = next->pn_next) {
             RootedValue elt(cx);
-            if (next->isKind(ParseNodeKind::PNK_EXPORT_SPEC)) {
+            if (next->isKind(ParseNodeKind::ExportSpec)) {
                 if (!exportSpecifier(next, &elt))
                     return false;
             } else {
                 if (!builder.exportBatchSpecifier(&pn->pn_pos, &elt))
                     return false;
             }
             elts.infallibleAppend(elt);
         }
         break;
 
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         if (!function(kid, AST_FUNC_DECL, &decl))
             return false;
         break;
 
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         if (!classDefinition(kid, false, &decl))
             return false;
         break;
 
-      case ParseNodeKind::PNK_VAR:
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET:
-        if (!variableDeclaration(kid, kind != ParseNodeKind::PNK_VAR, &decl))
+      case ParseNodeKind::Var:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let:
+        if (!variableDeclaration(kid, kind != ParseNodeKind::Var, &decl))
             return false;
         break;
 
       default:
           if (!expression(kid, &decl))
               return false;
           break;
     }
 
     RootedValue moduleSpec(cx, NullValue());
-    if (pn->isKind(ParseNodeKind::PNK_EXPORT_FROM) && !literal(pn->pn_right, &moduleSpec))
+    if (pn->isKind(ParseNodeKind::ExportFrom) && !literal(pn->pn_right, &moduleSpec))
         return false;
 
     RootedValue isDefault(cx, BooleanValue(false));
-    if (pn->isKind(ParseNodeKind::PNK_EXPORT_DEFAULT))
+    if (pn->isKind(ParseNodeKind::ExportDefault))
         isDefault.setBoolean(true);
 
     return builder.exportDeclaration(decl, elts, moduleSpec, isDefault, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::exportSpecifier(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_EXPORT_SPEC));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::ExportSpec));
 
     RootedValue bindingName(cx);
     RootedValue exportName(cx);
     return identifier(pn->pn_left, &bindingName) &&
            identifier(pn->pn_right, &exportName) &&
            builder.exportSpecifier(bindingName, exportName, &pn->pn_pos, dst);
 }
 
@@ -2139,17 +2139,17 @@ ASTSerializer::switchStatement(ParseNode
     RootedValue disc(cx);
 
     if (!expression(pn->pn_left, &disc))
         return false;
 
     ParseNode* listNode;
     bool lexical;
 
-    if (pn->pn_right->isKind(ParseNodeKind::PNK_LEXICALSCOPE)) {
+    if (pn->pn_right->isKind(ParseNodeKind::LexicalScope)) {
         listNode = pn->pn_right->pn_expr;
         lexical = true;
     } else {
         listNode = pn->pn_right;
         lexical = false;
     }
 
     NodeVector cases(cx);
@@ -2164,17 +2164,17 @@ ASTSerializer::switchStatement(ParseNode
     }
 
     return builder.switchStatement(disc, cases, lexical, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::catchClause(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_CATCH));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Catch));
     MOZ_ASSERT_IF(pn->pn_left, pn->pn_pos.encloses(pn->pn_left->pn_pos));
     MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
     RootedValue var(cx), body(cx);
 
     if (!optPattern(pn->pn_left, &var))
         return false;
 
@@ -2190,17 +2190,17 @@ ASTSerializer::tryStatement(ParseNode* p
     MOZ_ASSERT_IF(pn->pn_kid3, pn->pn_pos.encloses(pn->pn_kid3->pn_pos));
 
     RootedValue body(cx);
     if (!statement(pn->pn_kid1, &body))
         return false;
 
     RootedValue handler(cx, NullValue());
     if (ParseNode* catchScope = pn->pn_kid2) {
-        MOZ_ASSERT(catchScope->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+        MOZ_ASSERT(catchScope->isKind(ParseNodeKind::LexicalScope));
         if (!catchClause(catchScope->scopeBody(), &handler))
             return false;
     }
 
     RootedValue finally(cx);
     return optStatement(pn->pn_kid3, &finally) &&
            builder.tryStatement(body, handler, finally, &pn->pn_pos, dst);
 }
@@ -2208,18 +2208,18 @@ ASTSerializer::tryStatement(ParseNode* p
 bool
 ASTSerializer::forInit(ParseNode* pn, MutableHandleValue dst)
 {
     if (!pn) {
         dst.setMagic(JS_SERIALIZE_NO_NODE);
         return true;
     }
 
-    bool lexical = pn->isKind(ParseNodeKind::PNK_LET) || pn->isKind(ParseNodeKind::PNK_CONST);
-    return (lexical || pn->isKind(ParseNodeKind::PNK_VAR))
+    bool lexical = pn->isKind(ParseNodeKind::Let) || pn->isKind(ParseNodeKind::Const);
+    return (lexical || pn->isKind(ParseNodeKind::Var))
            ? variableDeclaration(pn, lexical, dst)
            : expression(pn, dst);
 }
 
 bool
 ASTSerializer::forOf(ParseNode* loop, ParseNode* head, HandleValue var, HandleValue stmt,
                          MutableHandleValue dst)
 {
@@ -2258,193 +2258,193 @@ ASTSerializer::classDefinition(ParseNode
 
 bool
 ASTSerializer::statement(ParseNode* pn, MutableHandleValue dst)
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_FUNCTION:
-      case ParseNodeKind::PNK_VAR:
+      case ParseNodeKind::Function:
+      case ParseNodeKind::Var:
         return declaration(pn, dst);
 
-      case ParseNodeKind::PNK_LET:
-      case ParseNodeKind::PNK_CONST:
+      case ParseNodeKind::Let:
+      case ParseNodeKind::Const:
         return declaration(pn, dst);
 
-      case ParseNodeKind::PNK_IMPORT:
+      case ParseNodeKind::Import:
         return importDeclaration(pn, dst);
 
-      case ParseNodeKind::PNK_EXPORT:
-      case ParseNodeKind::PNK_EXPORT_DEFAULT:
-      case ParseNodeKind::PNK_EXPORT_FROM:
+      case ParseNodeKind::Export:
+      case ParseNodeKind::ExportDefault:
+      case ParseNodeKind::ExportFrom:
         return exportDeclaration(pn, dst);
 
-      case ParseNodeKind::PNK_SEMI:
+      case ParseNodeKind::Semi:
         if (pn->pn_kid) {
             RootedValue expr(cx);
             return expression(pn->pn_kid, &expr) &&
                    builder.expressionStatement(expr, &pn->pn_pos, dst);
         }
         return builder.emptyStatement(&pn->pn_pos, dst);
 
-      case ParseNodeKind::PNK_LEXICALSCOPE:
+      case ParseNodeKind::LexicalScope:
         pn = pn->pn_expr;
-        if (!pn->isKind(ParseNodeKind::PNK_STATEMENTLIST))
+        if (!pn->isKind(ParseNodeKind::StatementList))
             return statement(pn, dst);
         MOZ_FALLTHROUGH;
 
-      case ParseNodeKind::PNK_STATEMENTLIST:
+      case ParseNodeKind::StatementList:
         return blockStatement(pn, dst);
 
-      case ParseNodeKind::PNK_IF:
+      case ParseNodeKind::If:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid1->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid2->pn_pos));
         MOZ_ASSERT_IF(pn->pn_kid3, pn->pn_pos.encloses(pn->pn_kid3->pn_pos));
 
         RootedValue test(cx), cons(cx), alt(cx);
 
         return expression(pn->pn_kid1, &test) &&
                statement(pn->pn_kid2, &cons) &&
                optStatement(pn->pn_kid3, &alt) &&
                builder.ifStatement(test, cons, alt, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_SWITCH:
+      case ParseNodeKind::Switch:
         return switchStatement(pn, dst);
 
-      case ParseNodeKind::PNK_TRY:
+      case ParseNodeKind::Try:
         return tryStatement(pn, dst);
 
-      case ParseNodeKind::PNK_WITH:
-      case ParseNodeKind::PNK_WHILE:
+      case ParseNodeKind::With:
+      case ParseNodeKind::While:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         RootedValue expr(cx), stmt(cx);
 
         return expression(pn->pn_left, &expr) &&
                statement(pn->pn_right, &stmt) &&
-               (pn->isKind(ParseNodeKind::PNK_WITH)
+               (pn->isKind(ParseNodeKind::With)
                 ? builder.withStatement(expr, stmt, &pn->pn_pos, dst)
                 : builder.whileStatement(expr, stmt, &pn->pn_pos, dst));
       }
 
-      case ParseNodeKind::PNK_DOWHILE:
+      case ParseNodeKind::DoWhile:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         RootedValue stmt(cx), test(cx);
 
         return statement(pn->pn_left, &stmt) &&
                expression(pn->pn_right, &test) &&
                builder.doWhileStatement(stmt, test, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_FOR:
+      case ParseNodeKind::For:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         ParseNode* head = pn->pn_left;
 
         MOZ_ASSERT_IF(head->pn_kid1, head->pn_pos.encloses(head->pn_kid1->pn_pos));
         MOZ_ASSERT_IF(head->pn_kid2, head->pn_pos.encloses(head->pn_kid2->pn_pos));
         MOZ_ASSERT_IF(head->pn_kid3, head->pn_pos.encloses(head->pn_kid3->pn_pos));
 
         RootedValue stmt(cx);
         if (!statement(pn->pn_right, &stmt))
             return false;
 
-        if (head->isKind(ParseNodeKind::PNK_FORIN) || head->isKind(ParseNodeKind::PNK_FOROF)) {
+        if (head->isKind(ParseNodeKind::ForIn) || head->isKind(ParseNodeKind::ForOf)) {
             RootedValue var(cx);
-            if (head->pn_kid1->isKind(ParseNodeKind::PNK_LEXICALSCOPE)) {
+            if (head->pn_kid1->isKind(ParseNodeKind::LexicalScope)) {
                 if (!variableDeclaration(head->pn_kid1->pn_expr, true, &var))
                     return false;
-            } else if (!head->pn_kid1->isKind(ParseNodeKind::PNK_VAR) &&
-                       !head->pn_kid1->isKind(ParseNodeKind::PNK_LET) &&
-                       !head->pn_kid1->isKind(ParseNodeKind::PNK_CONST))
+            } else if (!head->pn_kid1->isKind(ParseNodeKind::Var) &&
+                       !head->pn_kid1->isKind(ParseNodeKind::Let) &&
+                       !head->pn_kid1->isKind(ParseNodeKind::Const))
             {
                 if (!pattern(head->pn_kid1, &var))
                     return false;
             } else {
                 if (!variableDeclaration(head->pn_kid1,
-                                         head->pn_kid1->isKind(ParseNodeKind::PNK_LET) ||
-                                         head->pn_kid1->isKind(ParseNodeKind::PNK_CONST),
+                                         head->pn_kid1->isKind(ParseNodeKind::Let) ||
+                                         head->pn_kid1->isKind(ParseNodeKind::Const),
                                          &var))
                 {
                     return false;
                 }
             }
-            if (head->isKind(ParseNodeKind::PNK_FORIN))
+            if (head->isKind(ParseNodeKind::ForIn))
                 return forIn(pn, head, var, stmt, dst);
             return forOf(pn, head, var, stmt, dst);
         }
 
         RootedValue init(cx), test(cx), update(cx);
 
         return forInit(head->pn_kid1, &init) &&
                optExpression(head->pn_kid2, &test) &&
                optExpression(head->pn_kid3, &update) &&
                builder.forStatement(init, test, update, stmt, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_BREAK:
-      case ParseNodeKind::PNK_CONTINUE:
+      case ParseNodeKind::Break:
+      case ParseNodeKind::Continue:
       {
         RootedValue label(cx);
         RootedAtom pnAtom(cx, pn->pn_atom);
         return optIdentifier(pnAtom, nullptr, &label) &&
-               (pn->isKind(ParseNodeKind::PNK_BREAK)
+               (pn->isKind(ParseNodeKind::Break)
                 ? builder.breakStatement(label, &pn->pn_pos, dst)
                 : builder.continueStatement(label, &pn->pn_pos, dst));
       }
 
-      case ParseNodeKind::PNK_LABEL:
+      case ParseNodeKind::Label:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_expr->pn_pos));
 
         RootedValue label(cx), stmt(cx);
         RootedAtom pnAtom(cx, pn->as<LabeledStatement>().label());
         return identifier(pnAtom, nullptr, &label) &&
                statement(pn->pn_expr, &stmt) &&
                builder.labeledStatement(label, stmt, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_THROW:
+      case ParseNodeKind::Throw:
       {
         MOZ_ASSERT_IF(pn->pn_kid, pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
         RootedValue arg(cx);
 
         return optExpression(pn->pn_kid, &arg) &&
                builder.throwStatement(arg, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_RETURN:
+      case ParseNodeKind::Return:
       {
         MOZ_ASSERT_IF(pn->pn_kid, pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
         RootedValue arg(cx);
 
         return optExpression(pn->pn_kid, &arg) &&
                builder.returnStatement(arg, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_DEBUGGER:
+      case ParseNodeKind::Debugger:
         return builder.debuggerStatement(&pn->pn_pos, dst);
 
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         return classDefinition(pn, false, dst);
 
-      case ParseNodeKind::PNK_CLASSMETHODLIST:
+      case ParseNodeKind::ClassMethodList:
       {
         NodeVector methods(cx);
         if (!methods.reserve(pn->pn_count))
             return false;
 
         for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
@@ -2452,17 +2452,17 @@ ASTSerializer::statement(ParseNode* pn, 
             if (!classMethod(next, &prop))
                 return false;
             methods.infallibleAppend(prop);
         }
 
         return builder.classMethods(methods, dst);
       }
 
-      case ParseNodeKind::PNK_NOP:
+      case ParseNodeKind::Nop:
         return builder.emptyStatement(&pn->pn_pos, dst);
 
       default:
         LOCAL_NOT_REACHED("unexpected statement type");
     }
 }
 
 bool
@@ -2495,18 +2495,18 @@ ASTSerializer::classMethod(ParseNode* pn
 
 bool
 ASTSerializer::leftAssociate(ParseNode* pn, MutableHandleValue dst)
 {
     MOZ_ASSERT(pn->isArity(PN_LIST));
     MOZ_ASSERT(pn->pn_count >= 1);
 
     ParseNodeKind kind = pn->getKind();
-    bool lor = kind == ParseNodeKind::PNK_OR;
-    bool logop = lor || (kind == ParseNodeKind::PNK_AND);
+    bool lor = kind == ParseNodeKind::Or;
+    bool logop = lor || (kind == ParseNodeKind::And);
 
     ParseNode* head = pn->pn_head;
     RootedValue left(cx);
     if (!expression(head, &left))
         return false;
     for (ParseNode* next = head->pn_next; next; next = next->pn_next) {
         RootedValue right(cx);
         if (!expression(next, &right))
@@ -2575,155 +2575,155 @@ ASTSerializer::rightAssociate(ParseNode*
 
 bool
 ASTSerializer::expression(ParseNode* pn, MutableHandleValue dst)
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
       {
         ASTType type = pn->pn_funbox->function()->isArrow() ? AST_ARROW_EXPR : AST_FUNC_EXPR;
         return function(pn, type, dst);
       }
 
-      case ParseNodeKind::PNK_COMMA:
+      case ParseNodeKind::Comma:
       {
         NodeVector exprs(cx);
         return expressions(pn, exprs) &&
                builder.sequenceExpression(exprs, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_CONDITIONAL:
+      case ParseNodeKind::Conditional:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid1->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid2->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid3->pn_pos));
 
         RootedValue test(cx), cons(cx), alt(cx);
 
         return expression(pn->pn_kid1, &test) &&
                expression(pn->pn_kid2, &cons) &&
                expression(pn->pn_kid3, &alt) &&
                builder.conditionalExpression(test, cons, alt, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_OR:
-      case ParseNodeKind::PNK_AND:
+      case ParseNodeKind::Or:
+      case ParseNodeKind::And:
         return leftAssociate(pn, dst);
 
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PreDecrement:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
-        bool inc = pn->isKind(ParseNodeKind::PNK_PREINCREMENT);
+        bool inc = pn->isKind(ParseNodeKind::PreIncrement);
         RootedValue expr(cx);
         return expression(pn->pn_kid, &expr) &&
                builder.updateExpression(expr, inc, true, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PostDecrement:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
-        bool inc = pn->isKind(ParseNodeKind::PNK_POSTINCREMENT);
+        bool inc = pn->isKind(ParseNodeKind::PostIncrement);
         RootedValue expr(cx);
         return expression(pn->pn_kid, &expr) &&
                builder.updateExpression(expr, inc, false, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::PowAssign:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         AssignmentOperator op = aop(pn->getKind());
         LOCAL_ASSERT(op > AOP_ERR && op < AOP_LIMIT);
 
         RootedValue lhs(cx), rhs(cx);
         return pattern(pn->pn_left, &lhs) &&
                expression(pn->pn_right, &rhs) &&
                builder.assignmentExpression(op, lhs, rhs, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_PIPELINE:
-      case ParseNodeKind::PNK_ADD:
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_STRICTNE:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_INSTANCEOF:
+      case ParseNodeKind::Pipeline:
+      case ParseNodeKind::Add:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::StrictNe:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::In:
+      case ParseNodeKind::InstanceOf:
         return leftAssociate(pn, dst);
 
-      case ParseNodeKind::PNK_POW:
+      case ParseNodeKind::Pow:
         return rightAssociate(pn, dst);
 
-      case ParseNodeKind::PNK_DELETENAME:
-      case ParseNodeKind::PNK_DELETEPROP:
-      case ParseNodeKind::PNK_DELETEELEM:
-      case ParseNodeKind::PNK_DELETEEXPR:
-      case ParseNodeKind::PNK_TYPEOFNAME:
-      case ParseNodeKind::PNK_TYPEOFEXPR:
-      case ParseNodeKind::PNK_VOID:
-      case ParseNodeKind::PNK_NOT:
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_AWAIT:
-      case ParseNodeKind::PNK_NEG: {
+      case ParseNodeKind::DeleteName:
+      case ParseNodeKind::DeleteProp:
+      case ParseNodeKind::DeleteElem:
+      case ParseNodeKind::DeleteExpr:
+      case ParseNodeKind::TypeOfName:
+      case ParseNodeKind::TypeOfExpr:
+      case ParseNodeKind::Void:
+      case ParseNodeKind::Not:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Await:
+      case ParseNodeKind::Neg: {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
         UnaryOperator op = unop(pn->getKind());
         LOCAL_ASSERT(op > UNOP_ERR && op < UNOP_LIMIT);
 
         RootedValue expr(cx);
         return expression(pn->pn_kid, &expr) &&
                builder.unaryExpression(op, expr, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_SUPERCALL:
+      case ParseNodeKind::New:
+      case ParseNodeKind::TaggedTemplate:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::SuperCall:
       {
         ParseNode* next = pn->pn_head;
         MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
         RootedValue callee(cx);
-        if (pn->isKind(ParseNodeKind::PNK_SUPERCALL)) {
-            MOZ_ASSERT(next->isKind(ParseNodeKind::PNK_SUPERBASE));
+        if (pn->isKind(ParseNodeKind::SuperCall)) {
+            MOZ_ASSERT(next->isKind(ParseNodeKind::SuperBase));
             if (!builder.super(&next->pn_pos, &callee))
                 return false;
         } else {
             if (!expression(next, &callee))
                 return false;
         }
 
         NodeVector args(cx);
@@ -2734,27 +2734,27 @@ ASTSerializer::expression(ParseNode* pn,
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
             RootedValue arg(cx);
             if (!expression(next, &arg))
                 return false;
             args.infallibleAppend(arg);
         }
 
-        if (pn->getKind() == ParseNodeKind::PNK_TAGGED_TEMPLATE)
+        if (pn->getKind() == ParseNodeKind::TaggedTemplate)
             return builder.taggedTemplate(callee, args, &pn->pn_pos, dst);
 
         // SUPERCALL is Call(super, args)
-        return pn->isKind(ParseNodeKind::PNK_NEW)
+        return pn->isKind(ParseNodeKind::New)
                ? builder.newExpression(callee, args, &pn->pn_pos, dst)
 
             : builder.callExpression(callee, args, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_expr->pn_pos));
 
         RootedValue expr(cx);
         RootedValue propname(cx);
         RootedAtom pnAtom(cx, pn->pn_atom);
 
         if (pn->as<PropertyAccess>().isSuper()) {
@@ -2764,17 +2764,17 @@ ASTSerializer::expression(ParseNode* pn,
             if (!expression(pn->pn_expr, &expr))
                 return false;
         }
 
         return identifier(pnAtom, nullptr, &propname) &&
                builder.memberExpression(false, expr, propname, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         RootedValue left(cx), right(cx);
 
         if (pn->as<PropertyByValue>().isSuper()) {
             if (!builder.super(&pn->pn_left->pn_pos, &left))
@@ -2783,17 +2783,17 @@ ASTSerializer::expression(ParseNode* pn,
             if (!expression(pn->pn_left, &left))
                 return false;
         }
 
         return expression(pn->pn_right, &right) &&
                builder.memberExpression(true, left, right, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_CALLSITEOBJ:
+      case ParseNodeKind::CallSiteObj:
       {
         NodeVector raw(cx);
         if (!raw.reserve(pn->pn_head->pn_count))
             return false;
         for (ParseNode* next = pn->pn_head->pn_head; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
             RootedValue expr(cx);
@@ -2804,65 +2804,65 @@ ASTSerializer::expression(ParseNode* pn,
         NodeVector cooked(cx);
         if (!cooked.reserve(pn->pn_count - 1))
             return false;
 
         for (ParseNode* next = pn->pn_head->pn_next; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
             RootedValue expr(cx);
-            if (next->isKind(ParseNodeKind::PNK_RAW_UNDEFINED)) {
+            if (next->isKind(ParseNodeKind::RawUndefined)) {
                 expr.setUndefined();
             } else {
-                MOZ_ASSERT(next->isKind(ParseNodeKind::PNK_TEMPLATE_STRING));
+                MOZ_ASSERT(next->isKind(ParseNodeKind::TemplateString));
                 expr.setString(next->pn_atom);
             }
             cooked.infallibleAppend(expr);
         }
 
         return builder.callSiteObj(raw, cooked, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_ARRAY:
+      case ParseNodeKind::Array:
       {
         NodeVector elts(cx);
         if (!elts.reserve(pn->pn_count))
             return false;
 
         for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
-            if (next->isKind(ParseNodeKind::PNK_ELISION)) {
+            if (next->isKind(ParseNodeKind::Elision)) {
                 elts.infallibleAppend(NullValue());
             } else {
                 RootedValue expr(cx);
                 if (!expression(next, &expr))
                     return false;
                 elts.infallibleAppend(expr);
             }
         }
 
         return builder.arrayExpression(elts, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_SPREAD:
+      case ParseNodeKind::Spread:
       {
           RootedValue expr(cx);
           return expression(pn->pn_kid, &expr) &&
                  builder.spreadExpression(expr, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_COMPUTED_NAME:
+      case ParseNodeKind::ComputedName:
       {
          RootedValue name(cx);
          return expression(pn->pn_kid, &name) &&
                 builder.computedName(name, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_OBJECT:
+      case ParseNodeKind::Object:
       {
         NodeVector elts(cx);
         if (!elts.reserve(pn->pn_count))
             return false;
 
         for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
@@ -2870,23 +2870,23 @@ ASTSerializer::expression(ParseNode* pn,
             if (!property(next, &prop))
                 return false;
             elts.infallibleAppend(prop);
         }
 
         return builder.objectExpression(elts, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Name:
         return identifier(pn, dst);
 
-      case ParseNodeKind::PNK_THIS:
+      case ParseNodeKind::This:
         return builder.thisExpression(&pn->pn_pos, dst);
 
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
+      case ParseNodeKind::TemplateStringList:
       {
         NodeVector elts(cx);
         if (!elts.reserve(pn->pn_count))
             return false;
 
         for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
             MOZ_ASSERT(pn->pn_pos.encloses(next->pn_pos));
 
@@ -2894,98 +2894,98 @@ ASTSerializer::expression(ParseNode* pn,
             if (!expression(next, &expr))
                 return false;
             elts.infallibleAppend(expr);
         }
 
         return builder.templateLiteral(elts, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_REGEXP:
-      case ParseNodeKind::PNK_NUMBER:
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::String:
+      case ParseNodeKind::RegExp:
+      case ParseNodeKind::Number:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
         return literal(pn, dst);
 
-      case ParseNodeKind::PNK_YIELD_STAR:
+      case ParseNodeKind::YieldStar:
       {
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
         RootedValue arg(cx);
         return expression(pn->pn_kid, &arg) &&
                builder.yieldExpression(arg, Delegating, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_YIELD:
+      case ParseNodeKind::Yield:
       {
         MOZ_ASSERT_IF(pn->pn_kid, pn->pn_pos.encloses(pn->pn_kid->pn_pos));
 
         RootedValue arg(cx);
         return optExpression(pn->pn_kid, &arg) &&
                builder.yieldExpression(arg, NotDelegating, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         return classDefinition(pn, true, dst);
 
-      case ParseNodeKind::PNK_NEWTARGET:
+      case ParseNodeKind::NewTarget:
       {
-        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_POSHOLDER));
+        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PosHolder));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
-        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_POSHOLDER));
+        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PosHolder));
         MOZ_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));
 
         RootedValue newIdent(cx);
         RootedValue targetIdent(cx);
 
         RootedAtom newStr(cx, cx->names().new_);
         RootedAtom targetStr(cx, cx->names().target);
 
         return identifier(newStr, &pn->pn_left->pn_pos, &newIdent) &&
                identifier(targetStr, &pn->pn_right->pn_pos, &targetIdent) &&
                builder.metaProperty(newIdent, targetIdent, &pn->pn_pos, dst);
       }
 
-      case ParseNodeKind::PNK_SETTHIS:
+      case ParseNodeKind::SetThis:
         // SETTHIS is used to assign the result of a super() call to |this|.
         // It's not part of the original AST, so just forward to the call.
-        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::Name));
         return expression(pn->pn_right, dst);
 
       default:
         LOCAL_NOT_REACHED("unexpected expression type");
     }
 }
 
 bool
 ASTSerializer::propertyName(ParseNode* pn, MutableHandleValue dst)
 {
-    if (pn->isKind(ParseNodeKind::PNK_COMPUTED_NAME))
+    if (pn->isKind(ParseNodeKind::ComputedName))
         return expression(pn, dst);
-    if (pn->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME))
+    if (pn->isKind(ParseNodeKind::ObjectPropertyName))
         return identifier(pn, dst);
 
-    LOCAL_ASSERT(pn->isKind(ParseNodeKind::PNK_STRING) || pn->isKind(ParseNodeKind::PNK_NUMBER));
+    LOCAL_ASSERT(pn->isKind(ParseNodeKind::String) || pn->isKind(ParseNodeKind::Number));
 
     return literal(pn, dst);
 }
 
 bool
 ASTSerializer::property(ParseNode* pn, MutableHandleValue dst)
 {
-    if (pn->isKind(ParseNodeKind::PNK_MUTATEPROTO)) {
+    if (pn->isKind(ParseNodeKind::MutateProto)) {
         RootedValue val(cx);
         return expression(pn->pn_kid, &val) &&
                builder.prototypeMutation(val, &pn->pn_pos, dst);
     }
-    if (pn->isKind(ParseNodeKind::PNK_SPREAD))
+    if (pn->isKind(ParseNodeKind::Spread))
         return expression(pn, dst);
 
     PropKind kind;
     switch (pn->getOp()) {
       case JSOP_INITPROP:
         kind = PROP_INIT;
         break;
 
@@ -2996,89 +2996,89 @@ ASTSerializer::property(ParseNode* pn, M
       case JSOP_INITPROP_SETTER:
         kind = PROP_SETTER;
         break;
 
       default:
         LOCAL_NOT_REACHED("unexpected object-literal property");
     }
 
-    bool isShorthand = pn->isKind(ParseNodeKind::PNK_SHORTHAND);
+    bool isShorthand = pn->isKind(ParseNodeKind::Shorthand);
     bool isMethod =
-        pn->pn_right->isKind(ParseNodeKind::PNK_FUNCTION) &&
+        pn->pn_right->isKind(ParseNodeKind::Function) &&
         pn->pn_right->pn_funbox->function()->kind() == JSFunction::Method;
     RootedValue key(cx), val(cx);
     return propertyName(pn->pn_left, &key) &&
            expression(pn->pn_right, &val) &&
            builder.propertyInitializer(key, val, kind, isShorthand, isMethod, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::literal(ParseNode* pn, MutableHandleValue dst)
 {
     RootedValue val(cx);
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_STRING:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::String:
         val.setString(pn->pn_atom);
         break;
 
-      case ParseNodeKind::PNK_REGEXP:
+      case ParseNodeKind::RegExp:
       {
         RootedObject re1(cx, pn->as<RegExpLiteral>().objbox()->object);
         LOCAL_ASSERT(re1 && re1->is<RegExpObject>());
 
         RootedObject re2(cx, CloneRegExpObject(cx, re1.as<RegExpObject>()));
         if (!re2)
             return false;
 
         val.setObject(*re2);
         break;
       }
 
-      case ParseNodeKind::PNK_NUMBER:
+      case ParseNodeKind::Number:
         val.setNumber(pn->pn_dval);
         break;
 
-      case ParseNodeKind::PNK_NULL:
+      case ParseNodeKind::Null:
         val.setNull();
         break;
 
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
+      case ParseNodeKind::RawUndefined:
         val.setUndefined();
         break;
 
-      case ParseNodeKind::PNK_TRUE:
+      case ParseNodeKind::True:
         val.setBoolean(true);
         break;
 
-      case ParseNodeKind::PNK_FALSE:
+      case ParseNodeKind::False:
         val.setBoolean(false);
         break;
 
       default:
         LOCAL_NOT_REACHED("unexpected literal type");
     }
 
     return builder.literal(val, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::arrayPattern(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_ARRAY));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Array));
 
     NodeVector elts(cx);
     if (!elts.reserve(pn->pn_count))
         return false;
 
     for (ParseNode* next = pn->pn_head; next; next = next->pn_next) {
-        if (next->isKind(ParseNodeKind::PNK_ELISION)) {
+        if (next->isKind(ParseNodeKind::Elision)) {
             elts.infallibleAppend(NullValue());
-        } else if (next->isKind(ParseNodeKind::PNK_SPREAD)) {
+        } else if (next->isKind(ParseNodeKind::Spread)) {
             RootedValue target(cx);
             RootedValue spread(cx);
             if (!pattern(next->pn_kid, &target))
                 return false;
             if(!builder.spreadExpression(target, &next->pn_pos, &spread))
                 return false;
             elts.infallibleAppend(spread);
         } else {
@@ -3090,51 +3090,51 @@ ASTSerializer::arrayPattern(ParseNode* p
     }
 
     return builder.arrayPattern(elts, &pn->pn_pos, dst);
 }
 
 bool
 ASTSerializer::objectPattern(ParseNode* pn, MutableHandleValue dst)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Object));
 
     NodeVector elts(cx);
     if (!elts.reserve(pn->pn_count))
         return false;
 
     for (ParseNode* propdef = pn->pn_head; propdef; propdef = propdef->pn_next) {
-        if (propdef->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (propdef->isKind(ParseNodeKind::Spread)) {
             RootedValue target(cx);
             RootedValue spread(cx);
             if (!pattern(propdef->pn_kid, &target))
                 return false;
             if(!builder.spreadExpression(target, &propdef->pn_pos, &spread))
                 return false;
             elts.infallibleAppend(spread);
             continue;
         }
-        LOCAL_ASSERT(propdef->isKind(ParseNodeKind::PNK_MUTATEPROTO) != propdef->isOp(JSOP_INITPROP));
+        LOCAL_ASSERT(propdef->isKind(ParseNodeKind::MutateProto) != propdef->isOp(JSOP_INITPROP));
 
         RootedValue key(cx);
         ParseNode* target;
-        if (propdef->isKind(ParseNodeKind::PNK_MUTATEPROTO)) {
+        if (propdef->isKind(ParseNodeKind::MutateProto)) {
             RootedValue pname(cx, StringValue(cx->names().proto));
             if (!builder.literal(pname, &propdef->pn_pos, &key))
                 return false;
             target = propdef->pn_kid;
         } else {
             if (!propertyName(propdef->pn_left, &key))
                 return false;
             target = propdef->pn_right;
         }
 
         RootedValue patt(cx), prop(cx);
         if (!pattern(target, &patt) ||
-            !builder.propertyPattern(key, patt, propdef->isKind(ParseNodeKind::PNK_SHORTHAND),
+            !builder.propertyPattern(key, patt, propdef->isKind(ParseNodeKind::Shorthand),
                                      &propdef->pn_pos,
                                      &prop))
         {
             return false;
         }
 
         elts.infallibleAppend(prop);
     }
@@ -3144,20 +3144,20 @@ ASTSerializer::objectPattern(ParseNode* 
 
 bool
 ASTSerializer::pattern(ParseNode* pn, MutableHandleValue dst)
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_OBJECT:
+      case ParseNodeKind::Object:
         return objectPattern(pn, dst);
 
-      case ParseNodeKind::PNK_ARRAY:
+      case ParseNodeKind::Array:
         return arrayPattern(pn, dst);
 
       default:
         return expression(pn, dst);
     }
 }
 
 bool
@@ -3212,45 +3212,45 @@ bool
 ASTSerializer::functionArgsAndBody(ParseNode* pn, NodeVector& args, NodeVector& defaults,
                                    bool isAsync, bool isExpression,
                                    MutableHandleValue body, MutableHandleValue rest)
 {
     ParseNode* pnargs;
     ParseNode* pnbody;
 
     /* Extract the args and body separately. */
-    if (pn->isKind(ParseNodeKind::PNK_PARAMSBODY)) {
+    if (pn->isKind(ParseNodeKind::ParamsBody)) {
         pnargs = pn;
         pnbody = pn->last();
     } else {
         pnargs = nullptr;
         pnbody = pn;
     }
 
-    if (pnbody->isKind(ParseNodeKind::PNK_LEXICALSCOPE))
+    if (pnbody->isKind(ParseNodeKind::LexicalScope))
         pnbody = pnbody->scopeBody();
 
     /* Serialize the arguments and body. */
     switch (pnbody->getKind()) {
-      case ParseNodeKind::PNK_RETURN: /* expression closure, no destructured args */
+      case ParseNodeKind::Return: /* expression closure, no destructured args */
         return functionArgs(pn, pnargs, args, defaults, rest) &&
                expression(pnbody->pn_kid, body);
 
-      case ParseNodeKind::PNK_STATEMENTLIST:     /* statement closure */
+      case ParseNodeKind::StatementList:     /* statement closure */
       {
         ParseNode* pnstart = pnbody->pn_head;
 
         // Skip over initial yield in generator.
-        if (pnstart && pnstart->isKind(ParseNodeKind::PNK_INITIALYIELD))
+        if (pnstart && pnstart->isKind(ParseNodeKind::InitialYield))
             pnstart = pnstart->pn_next;
 
         // Async arrow with expression body is converted into STATEMENTLIST
         // to insert initial yield.
         if (isAsync && isExpression) {
-            MOZ_ASSERT(pnstart->getKind() == ParseNodeKind::PNK_RETURN);
+            MOZ_ASSERT(pnstart->getKind() == ParseNodeKind::Return);
             return functionArgs(pn, pnargs, args, defaults, rest) &&
                    expression(pnstart->pn_kid, body);
         }
 
         return functionArgs(pn, pnargs, args, defaults, rest) &&
                functionBody(pnstart, &pnbody->pn_pos, body);
       }
 
@@ -3271,32 +3271,32 @@ ASTSerializer::functionArgs(ParseNode* p
     bool defaultsNull = true;
     MOZ_ASSERT(defaults.empty(),
                "must be initially empty for it to be proper to clear this "
                "when there are no defaults");
 
     for (ParseNode* arg = pnargs->pn_head; arg && arg != pnargs->last(); arg = arg->pn_next) {
         ParseNode* pat;
         ParseNode* defNode;
-        if (arg->isKind(ParseNodeKind::PNK_NAME) ||
-            arg->isKind(ParseNodeKind::PNK_ARRAY) ||
-            arg->isKind(ParseNodeKind::PNK_OBJECT))
+        if (arg->isKind(ParseNodeKind::Name) ||
+            arg->isKind(ParseNodeKind::Array) ||
+            arg->isKind(ParseNodeKind::Object))
         {
             pat = arg;
             defNode = nullptr;
         } else {
-            MOZ_ASSERT(arg->isKind(ParseNodeKind::PNK_ASSIGN));
+            MOZ_ASSERT(arg->isKind(ParseNodeKind::Assign));
             pat = arg->pn_left;
             defNode = arg->pn_right;
         }
 
         // Process the name or pattern.
-        MOZ_ASSERT(pat->isKind(ParseNodeKind::PNK_NAME) ||
-                   pat->isKind(ParseNodeKind::PNK_ARRAY) ||
-                   pat->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(pat->isKind(ParseNodeKind::Name) ||
+                   pat->isKind(ParseNodeKind::Array) ||
+                   pat->isKind(ParseNodeKind::Object));
         if (!pattern(pat, &node))
             return false;
         if (rest.isUndefined() && arg->pn_next == pnargs->last()) {
             rest.setObject(node.toObject());
         } else {
             if (!args.append(node))
                 return false;
         }
@@ -3501,17 +3501,17 @@ reflect_parse(JSContext* cx, uint32_t ar
         if (!builder.init())
             return false;
 
         ModuleSharedContext modulesc(cx, module, &cx->global()->emptyGlobalScope(), builder);
         pn = parser.moduleBody(&modulesc);
         if (!pn)
             return false;
 
-        MOZ_ASSERT(pn->getKind() == ParseNodeKind::PNK_MODULE);
+        MOZ_ASSERT(pn->getKind() == ParseNodeKind::Module);
         pn = pn->pn_body;
     }
 
     RootedValue val(cx);
     if (!serialize.program(pn, &val)) {
         args.rval().setNull();
         return false;
     }
--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -799,17 +799,17 @@ BinASTParser::parseStatementAux(const Bi
 
         if (!left)
             return raiseMissingField("ForInStatement", BinField::Left);
         if (!right)
             return raiseMissingField("ForInStatement", BinField::Right);
         if (!body)
             return raiseMissingField("ForInStatement", BinField::Body);
 
-        TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::PNK_FORIN, left, right,
+        TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right,
                                                     tokenizer_->pos(start)));
         TRY_VAR(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0));
 
         if (!scope.isEmpty()) {
             TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
             TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
         }
         break;
@@ -832,17 +832,17 @@ BinASTParser::parseBreakOrContinueStatem
     const auto start = tokenizer_->offset();
     ParseNode* label(nullptr);
 
     for (auto field : fields) {
         switch (field) {
           case BinField::Label:
             MOZ_TRY_VAR(label, parsePattern());
 
-            if (label && !label->isKind(ParseNodeKind::PNK_NAME))
+            if (label && !label->isKind(ParseNodeKind::Name))
                 return raiseError("ContinueStatement | BreakStatement - Label MUST be an identifier"); // FIXME: This should be changed in the grammar.
 
             break;
           default:
             return raiseInvalidField("ContinueStatement", field);
         }
     }
 
@@ -1028,17 +1028,17 @@ BinASTParser::parseFunctionAux(const Bin
             break;
           default:
             return raiseInvalidField("Function", field);
         }
     }
 
     // Inject default values for absent fields.
     if (!params)
-        TRY_VAR(params, new_<ListNode>(ParseNodeKind::PNK_PARAMSBODY, tokenizer_->pos()));
+        TRY_VAR(params, new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos()));
 
     if (!body)
         TRY_VAR(body, factory_.newStatementList(tokenizer_->pos()));
 
     if (kind == BinKind::FunctionDeclaration && !id) {
         // The name is compulsory only for function declarations.
         return raiseMissingField("FunctionDeclaration", BinField::Id);
     }
@@ -1047,31 +1047,31 @@ BinASTParser::parseFunctionAux(const Bin
     if (isMethod(kind) && !key)
         return raiseMissingField("method", BinField::Key);
 
     if (id)
         fun->initAtom(id->pn_atom);
 
     MOZ_ASSERT(params->isArity(PN_LIST));
 
-    if (!(body->isKind(ParseNodeKind::PNK_LEXICALSCOPE) &&
-          body->pn_u.scope.body->isKind(ParseNodeKind::PNK_STATEMENTLIST)))
+    if (!(body->isKind(ParseNodeKind::LexicalScope) &&
+          body->pn_u.scope.body->isKind(ParseNodeKind::StatementList)))
     {
         // Promote to lexical scope + statement list.
-        if (!body->isKind(ParseNodeKind::PNK_STATEMENTLIST)) {
+        if (!body->isKind(ParseNodeKind::StatementList)) {
             TRY_DECL(list, factory_.newStatementList(tokenizer_->pos(start)));
 
             list->initList(body);
             body = list;
         }
 
         // Promote to lexical scope.
         TRY_VAR(body, factory_.newLexicalScope(nullptr, body));
     }
-    MOZ_ASSERT(body->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+    MOZ_ASSERT(body->isKind(ParseNodeKind::LexicalScope));
 
     MOZ_TRY_VAR(body, appendDirectivesToBody(body, directives));
 
     params->appendWithoutOrderAssumption(body);
 
     TokenPos pos = tokenizer_->pos(start);
     TRY_DECL(function, kind == BinKind::FunctionDeclaration
                        ? factory_.newFunctionStatement(pos)
@@ -1159,41 +1159,41 @@ BinASTParser::parseVariableDeclarationAu
 {
     const size_t start = tokenizer_->offset();
 
     ParseNode* result(nullptr);
     switch (kind) {
       default:
         return raiseInvalidKind("VariableDeclaration", kind);
       case BinKind::VariableDeclaration:
-        ParseNodeKind pnk = ParseNodeKind::PNK_LIMIT;
+        ParseNodeKind pnk = ParseNodeKind::Limit;
 
         for (auto field : fields) {
             switch (field) {
               case BinField::Kind: {
                 Maybe<Chars> kindName;
                 MOZ_TRY(readString(kindName));
 
                 if (*kindName == "let")
-                    pnk = ParseNodeKind::PNK_LET;
+                    pnk = ParseNodeKind::Let;
                 else if (*kindName == "var")
-                    pnk = ParseNodeKind::PNK_VAR;
+                    pnk = ParseNodeKind::Var;
                 else if (*kindName == "const")
-                    pnk = ParseNodeKind::PNK_CONST;
+                    pnk = ParseNodeKind::Const;
                 else
                     return raiseInvalidEnum("VariableDeclaration", *kindName);
 
                 break;
               }
               case BinField::Declarations: {
                 uint32_t length;
                 AutoList guard(*tokenizer_);
 
                 TRY(tokenizer_->enterList(length, guard));
-                TRY_VAR(result, factory_.newDeclarationList(ParseNodeKind::PNK_CONST /*Placeholder*/,
+                TRY_VAR(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/,
                                                             tokenizer_->pos(start)));
 
                 for (uint32_t i = 0; i < length; ++i) {
                     ParseNode* current;
                     MOZ_TRY_VAR(current, parseVariableDeclarator());
                     MOZ_ASSERT(current);
 
                     result->appendWithoutOrderAssumption(current);
@@ -1202,22 +1202,22 @@ BinASTParser::parseVariableDeclarationAu
                 TRY(guard.done());
                 break;
               }
               default:
                 return raiseInvalidField("VariableDeclaration", field);
             }
         }
 
-        if (!result || pnk == ParseNodeKind::PNK_LIMIT)
+        if (!result || pnk == ParseNodeKind::Limit)
             return raiseMissingField("VariableDeclaration", BinField::Declarations);
 
         result->setKind(pnk);
 
-        MOZ_ASSERT(!result->isKind(ParseNodeKind::PNK_NOP));
+        MOZ_ASSERT(!result->isKind(ParseNodeKind::Nop));
     }
 
     return result;
 }
 
 
 JS::Result<ParseNode*>
 BinASTParser::parseExpressionStatementAux(const BinKind kind, const BinFields& fields)
@@ -1275,31 +1275,31 @@ BinASTParser::parseVariableDeclarator()
 
     TRY(guard.done());
     if (!id)
         return raiseMissingField("VariableDeclarator", BinField::Id);
 
     ParseNode* result(nullptr);
 
     // FIXME: Documentation in ParseNode is clearly obsolete.
-    if (id->isKind(ParseNodeKind::PNK_NAME)) {
+    if (id->isKind(ParseNodeKind::Name)) {
         // `var foo [= bar]``
         TRY_VAR(result, factory_.newName(id->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_));
 
         if (init)
             result->pn_expr = init;
 
     } else {
         // `var pattern = bar`
         if (!init) {
             // Here, `init` is required.
             return raiseMissingField("VariableDeclarator (with non-trivial pattern)", BinField::Init);
         }
 
-        TRY_VAR(result, factory_.newAssignment(ParseNodeKind::PNK_ASSIGN, id, init));
+        TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, id, init));
     }
 
     return result;
 }
 
 JS::Result<ParseNode*>
 BinASTParser::parseExpressionList(bool acceptElisions)
 {
@@ -1551,65 +1551,65 @@ BinASTParser::parseExpressionAux(const B
             return raiseMissingField("UpdateExpression", BinField::Argument);
         if (operation.isNothing())
             return raiseMissingField("UpdateExpression", BinField::Operator);
 
         // In case of absent optional fields, inject default values.
         if (prefix.isNothing())
             prefix.emplace(false);
 
-        ParseNodeKind pnk = ParseNodeKind::PNK_LIMIT;
+        ParseNodeKind pnk = ParseNodeKind::Limit;
         if (kind == BinKind::UnaryExpression) {
             if (*operation == "-") {
-                pnk = ParseNodeKind::PNK_NEG;
+                pnk = ParseNodeKind::Neg;
             } else if (*operation == "+") {
-                pnk = ParseNodeKind::PNK_POS;
+                pnk = ParseNodeKind::Pos;
             } else if (*operation == "!") {
-                pnk = ParseNodeKind::PNK_NOT;
+                pnk = ParseNodeKind::Not;
             } else if (*operation == "~") {
-                pnk = ParseNodeKind::PNK_BITNOT;
+                pnk = ParseNodeKind::BitNot;
             } else if (*operation == "typeof") {
-                if (expr->isKind(ParseNodeKind::PNK_NAME))
-                    pnk = ParseNodeKind::PNK_TYPEOFNAME;
+                if (expr->isKind(ParseNodeKind::Name))
+                    pnk = ParseNodeKind::TypeOfName;
                 else
-                    pnk = ParseNodeKind::PNK_TYPEOFEXPR;
+                    pnk = ParseNodeKind::TypeOfExpr;
             } else if (*operation == "void") {
-                pnk = ParseNodeKind::PNK_VOID;
+                pnk = ParseNodeKind::Void;
             } else if (*operation == "delete") {
                 switch (expr->getKind()) {
-                  case ParseNodeKind::PNK_NAME:
+                  case ParseNodeKind::Name:
                     expr->setOp(JSOP_DELNAME);
-                    pnk = ParseNodeKind::PNK_DELETENAME;
+                    pnk = ParseNodeKind::DeleteName;
                     break;
-                  case ParseNodeKind::PNK_DOT:
-                    pnk = ParseNodeKind::PNK_DELETEPROP;
+                  case ParseNodeKind::Dot:
+                    pnk = ParseNodeKind::DeleteProp;
                     break;
-                  case ParseNodeKind::PNK_ELEM:
-                    pnk = ParseNodeKind::PNK_DELETEELEM;
+                  case ParseNodeKind::Elem:
+                    pnk = ParseNodeKind::DeleteElem;
                     break;
                   default:
-                    pnk = ParseNodeKind::PNK_DELETEEXPR;
+                    pnk = ParseNodeKind::DeleteExpr;
                 }
             } else {
                 return raiseInvalidEnum("UnaryOperator", *operation);
             }
         } else if (kind == BinKind::UpdateExpression) {
-            if (!expr->isKind(ParseNodeKind::PNK_NAME) && !factory_.isPropertyAccess(expr))
+            if (!expr->isKind(ParseNodeKind::Name) && !factory_.isPropertyAccess(expr))
                 return raiseError("Invalid increment/decrement operand"); // FIXME: Shouldn't this be part of the syntax?
 
             if (*operation == "++") {
                 if (*prefix)
-                    pnk = ParseNodeKind::PNK_PREINCREMENT;
+                    pnk = ParseNodeKind::PreIncrement;
                 else
-                    pnk = ParseNodeKind::PNK_POSTINCREMENT;
+                    pnk = ParseNodeKind::PostIncrement;
             } else if (*operation == "--") {
                 if (*prefix)
-                    pnk = ParseNodeKind::PNK_PREDECREMENT;
+                    pnk = ParseNodeKind::PreDecrement;
                 else
-                    pnk = ParseNodeKind::PNK_POSTDECREMENT;
+                    pnk = ParseNodeKind::PostDecrement;
             } else {
                 return raiseInvalidEnum("UpdateOperator", *operation);
             }
         }
 
         TRY_VAR(result, factory_.newUnary(pnk, start, expr));
 
         break;
@@ -1639,70 +1639,70 @@ BinASTParser::parseExpressionAux(const B
             return raiseMissingField("LogicalExpression | BinaryExpression", BinField::Left);
         if (!right)
             return raiseMissingField("LogicalExpression | BinaryExpression", BinField::Right);
         if (operation.isNothing())
             return raiseMissingField("LogicalExpression | BinaryExpression", BinField::Operator);
 
         // FIXME: Instead of Chars, we should use atoms and comparison
         // between atom ptr.
-        ParseNodeKind pnk = ParseNodeKind::PNK_LIMIT;
+        ParseNodeKind pnk = ParseNodeKind::Limit;
         if (*operation == "==")
-            pnk = ParseNodeKind::PNK_EQ;
+            pnk = ParseNodeKind::Eq;
         else if (*operation == "!=")
-            pnk = ParseNodeKind::PNK_NE;
+            pnk = ParseNodeKind::Ne;
         else if (*operation == "===")
-            pnk = ParseNodeKind::PNK_STRICTEQ;
+            pnk = ParseNodeKind::StrictEq;
         else if (*operation == "!==")
-            pnk = ParseNodeKind::PNK_STRICTNE;
+            pnk = ParseNodeKind::StrictNe;
         else if (*operation == "<")
-            pnk = ParseNodeKind::PNK_LT;
+            pnk = ParseNodeKind::Lt;
         else if (*operation == "<=")
-            pnk = ParseNodeKind::PNK_LE;
+            pnk = ParseNodeKind::Le;
         else if (*operation == ">")
-            pnk = ParseNodeKind::PNK_GT;
+            pnk = ParseNodeKind::Gt;
         else if (*operation == ">=")
-            pnk = ParseNodeKind::PNK_GE;
+            pnk = ParseNodeKind::Ge;
         else if (*operation == "<<")
-            pnk = ParseNodeKind::PNK_LSH;
+            pnk = ParseNodeKind::Lsh;
         else if (*operation == ">>")
-            pnk = ParseNodeKind::PNK_RSH;
+            pnk = ParseNodeKind::Rsh;
         else if (*operation == ">>>")
-            pnk = ParseNodeKind::PNK_URSH;
+            pnk = ParseNodeKind::Ursh;
         else if (*operation == "+")
-            pnk = ParseNodeKind::PNK_ADD;
+            pnk = ParseNodeKind::Add;
         else if (*operation == "-")
-            pnk = ParseNodeKind::PNK_SUB;
+            pnk = ParseNodeKind::Sub;
         else if (*operation == "*")
-            pnk = ParseNodeKind::PNK_STAR;
+            pnk = ParseNodeKind::Star;
         else if (*operation == "/")
-            pnk = ParseNodeKind::PNK_DIV;
+            pnk = ParseNodeKind::Div;
         else if (*operation == "%")
-            pnk = ParseNodeKind::PNK_MOD;
+            pnk = ParseNodeKind::Mod;
         else if (*operation == "|")
-            pnk = ParseNodeKind::PNK_BITOR;
+            pnk = ParseNodeKind::BitOr;
         else if (*operation == "^")
-            pnk = ParseNodeKind::PNK_BITXOR;
+            pnk = ParseNodeKind::BitXor;
         else if (*operation == "&")
-            pnk = ParseNodeKind::PNK_BITAND;
+            pnk = ParseNodeKind::BitAnd;
         else if (*operation == "in")
-            pnk = ParseNodeKind::PNK_IN;
+            pnk = ParseNodeKind::In;
         else if (*operation == "instanceof")
-            pnk = ParseNodeKind::PNK_INSTANCEOF;
+            pnk = ParseNodeKind::InstanceOf;
         else if (*operation == "||")
-            pnk = ParseNodeKind::PNK_OR;
+            pnk = ParseNodeKind::Or;
         else if (*operation == "&&")
-            pnk = ParseNodeKind::PNK_AND;
+            pnk = ParseNodeKind::And;
         else if (*operation == "**")
-            pnk = ParseNodeKind::PNK_POW;
+            pnk = ParseNodeKind::Pow;
         else
             return raiseInvalidEnum("BinaryOperator | LogicalOperator", *operation);
 
         if (left->isKind(pnk) &&
-            pnk != ParseNodeKind::PNK_POW /* ParseNodeKind::PNK_POW is not left-associative */)
+            pnk != ParseNodeKind::Pow /* ParseNodeKind::Pow is not left-associative */)
         {
             // Regroup left-associative operations into lists.
             left->appendWithoutOrderAssumption(right);
             result = left;
         } else {
             TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start)));
 
             list->appendWithoutOrderAssumption(left);
@@ -1737,41 +1737,41 @@ BinASTParser::parseExpressionAux(const B
         if (!right)
             return raiseMissingField("AssignmentExpression", BinField::Right);
         if (operation.isNothing())
             return raiseMissingField("AssignmentExpression", BinField::Operator);
 
         // FIXME: Instead of Chars, we should use atoms and comparison
         // between atom ptr.
         // FIXME: We should probably turn associative operations into lists.
-        ParseNodeKind pnk = ParseNodeKind::PNK_LIMIT;
+        ParseNodeKind pnk = ParseNodeKind::Limit;
         if (*operation == "=")
-            pnk = ParseNodeKind::PNK_ASSIGN;
+            pnk = ParseNodeKind::Assign;
         else if (*operation == "+=")
-            pnk = ParseNodeKind::PNK_ADDASSIGN;
+            pnk = ParseNodeKind::AddAssign;
         else if (*operation == "-=")
-            pnk = ParseNodeKind::PNK_SUBASSIGN;
+            pnk = ParseNodeKind::SubAssign;
         else if (*operation == "*=")
-            pnk = ParseNodeKind::PNK_MULASSIGN;
+            pnk = ParseNodeKind::MulAssign;
         else if (*operation == "/=")
-            pnk = ParseNodeKind::PNK_DIVASSIGN;
+            pnk = ParseNodeKind::DivAssign;
         else if (*operation == "%=")
-            pnk = ParseNodeKind::PNK_MODASSIGN;
+            pnk = ParseNodeKind::ModAssign;
         else if (*operation == "<<=")
-            pnk = ParseNodeKind::PNK_LSHASSIGN;
+            pnk = ParseNodeKind::LshAssign;
         else if (*operation == ">>=")
-            pnk = ParseNodeKind::PNK_RSHASSIGN;
+            pnk = ParseNodeKind::RshAssign;
         else if (*operation == ">>>=")
-            pnk = ParseNodeKind::PNK_URSHASSIGN;
+            pnk = ParseNodeKind::UrshAssign;
         else if (*operation == "|=")
-            pnk = ParseNodeKind::PNK_BITORASSIGN;
+            pnk = ParseNodeKind::BitOrAssign;
         else if (*operation == "^=")
-            pnk = ParseNodeKind::PNK_BITXORASSIGN;
+            pnk = ParseNodeKind::BitXorAssign;
         else if (*operation == "&=")
-            pnk = ParseNodeKind::PNK_BITANDASSIGN;
+            pnk = ParseNodeKind::BitAndAssign;
         else
             return raiseInvalidEnum("AssignmentOperator", *operation);
 
         TRY_VAR(result, factory_.newAssignment(pnk, left, right));
 
         break;
       }
       case BinKind::BracketExpression:
@@ -1833,18 +1833,18 @@ BinASTParser::parseExpressionAux(const B
             return raiseMissingField("NewExpression", BinField::Callee);
 
         // In case of absent optional fields, inject default values.
         if (!result)
             TRY_VAR(result, factory_.newArrayLiteral(start));
 
         ParseNodeKind pnk =
             kind == BinKind::CallExpression
-            ? ParseNodeKind::PNK_CALL
-            : ParseNodeKind::PNK_NEW;
+            ? ParseNodeKind::Call
+            : ParseNodeKind::New;
         result->setKind(pnk);
         result->prepend(callee);
 
         break;
       }
       case BinKind::SequenceExpression: {
         for (auto field : fields) {
             switch (field) {
@@ -1854,17 +1854,17 @@ BinASTParser::parseExpressionAux(const B
               default:
                 return raiseInvalidField("SequenceExpression", field);
             }
         }
 
         if (!result)
             return raiseMissingField("SequenceExpression", BinField::Expression);
 
-        result->setKind(ParseNodeKind::PNK_COMMA);
+        result->setKind(ParseNodeKind::Comma);
         break;
       }
       default:
         return raiseInvalidKind("Expression", kind);
     }
 
     return result;
 }
@@ -1932,17 +1932,17 @@ BinASTParser::parseArrayExpressionAux(co
             return raiseInvalidField("ArrayExpression", field);
         }
     }
 
     // Inject default values for absent fields.
     if (!result)
         TRY_VAR(result, factory_.newArrayLiteral(tokenizer_->offset()));
 
-    MOZ_ASSERT(result->isKind(ParseNodeKind::PNK_ARRAY));
+    MOZ_ASSERT(result->isKind(ParseNodeKind::Array));
     return result;
 }
 
 JS::Result<ParseNode*>
 BinASTParser::parseObjectExpressionAux(const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ObjectExpression);
 
@@ -1957,22 +1957,22 @@ BinASTParser::parseObjectExpressionAux(c
             return raiseInvalidField("Property | Method", field);
         }
     }
 
     if (!result)
         TRY_VAR(result, factory_.newObjectLiteral(tokenizer_->offset()));
 
     MOZ_ASSERT(result->isArity(PN_LIST));
-    MOZ_ASSERT(result->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(result->isKind(ParseNodeKind::Object));
 
 #if defined(DEBUG)
     // Sanity check.
     for (ParseNode* iter = result->pn_head; iter != nullptr; iter = iter->pn_next) {
-        MOZ_ASSERT(iter->isKind(ParseNodeKind::PNK_COLON));
+        MOZ_ASSERT(iter->isKind(ParseNodeKind::Colon));
         MOZ_ASSERT(iter->pn_left != nullptr);
         MOZ_ASSERT(iter->pn_right != nullptr);
     }
 #endif // defined(DEBUG)
 
     return result;
 }
 
@@ -2003,17 +2003,17 @@ BinASTParser::parseMemberExpressionAux(c
     // In case of absent required fields, fail.
     if (!object)
         return raiseMissingField("MemberExpression", BinField::Object);
     if (!property)
         return raiseMissingField("MemberExpression", BinField::Property);
 
     ParseNode* result(nullptr);
     if (kind == BinKind::DotExpression) {
-        MOZ_ASSERT(property->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT(property->isKind(ParseNodeKind::Name));
         PropertyName* name = property->pn_atom->asPropertyName();
         TRY_VAR(result, factory_.newPropertyAccess(object, name, tokenizer_->offset()));
     } else {
         TRY_VAR(result, factory_.newPropertyByValue(object, property, tokenizer_->offset()));
     }
 
     return result;
 }
@@ -2069,17 +2069,17 @@ BinASTParser::parseSwitchCase()
             return raiseInvalidField("SwitchCase", field);
         }
     }
 
     TRY(guard.done());
     if (!statements)
         return raiseMissingField("SwitchCase", BinField::Consequent);
 
-    MOZ_ASSERT(statements->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+    MOZ_ASSERT(statements->isKind(ParseNodeKind::StatementList));
 
     TRY_DECL(result, factory_.newCaseOrDefault(start, test, statements));
 
     return result;
 }
 
 JS::Result<ParseNode*>
 BinASTParser::parseCatchClause()
@@ -2135,17 +2135,17 @@ BinASTParser::parseCatchClause()
 
 JS::Result<ParseNode*>
 BinASTParser::parseArgumentList()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     TRY(tokenizer_->enterList(length, guard));
-    ParseNode* result = new_<ListNode>(ParseNodeKind::PNK_PARAMSBODY, tokenizer_->pos());
+    ParseNode* result = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos());
 
     for (uint32_t i = 0; i < length; ++i) {
         ParseNode* pattern;
         MOZ_TRY_VAR(pattern, parsePattern());
 
         result->appendWithoutOrderAssumption(pattern);
     }
 
@@ -2277,17 +2277,17 @@ BinASTParser::parseObjectMember()
       case BinKind::ObjectMethod:
       case BinKind::ObjectGetter:
       case BinKind::ObjectSetter:
         MOZ_TRY_VAR(result, parseFunctionAux(kind, fields));
 
         if (!result)
             return raiseEmpty("ObjectMethod");
 
-        MOZ_ASSERT(result->isKind(ParseNodeKind::PNK_COLON));
+        MOZ_ASSERT(result->isKind(ParseNodeKind::Colon));
         break;
       default:
         return raiseInvalidKind("ObjectMember", kind);
     }
 
     TRY(guard.done());
     MOZ_ASSERT(result);
     return result;
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -60,17 +60,17 @@ class BreakableControl;
 class LabelControl;
 class LoopControl;
 class ForOfLoopControl;
 class TryFinallyControl;
 
 static bool
 ParseNodeRequiresSpecialLineNumberNotes(ParseNode* pn)
 {
-    return pn->getKind() == ParseNodeKind::PNK_WHILE || pn->getKind() == ParseNodeKind::PNK_FOR;
+    return pn->getKind() == ParseNodeKind::While || pn->getKind() == ParseNodeKind::For;
 }
 
 // A cache that tracks superfluous TDZ checks.
 //
 // Each basic block should have a TDZCheckCache in scope. Some NestableControl
 // subclasses contain a TDZCheckCache.
 class BytecodeEmitter::TDZCheckCache : public Nestable<BytecodeEmitter::TDZCheckCache>
 {
@@ -2569,38 +2569,38 @@ bool
 BytecodeEmitter::emitLoopHead(ParseNode* nextpn, JumpTarget* top)
 {
     if (nextpn) {
         /*
          * Try to give the JSOP_LOOPHEAD the same line number as the next
          * instruction. nextpn is often a block, in which case the next
          * instruction typically comes from the first statement inside.
          */
-        if (nextpn->isKind(ParseNodeKind::PNK_LEXICALSCOPE))
+        if (nextpn->isKind(ParseNodeKind::LexicalScope))
             nextpn = nextpn->scopeBody();
-        MOZ_ASSERT_IF(nextpn->isKind(ParseNodeKind::PNK_STATEMENTLIST), nextpn->isArity(PN_LIST));
-        if (nextpn->isKind(ParseNodeKind::PNK_STATEMENTLIST) && nextpn->pn_head)
+        MOZ_ASSERT_IF(nextpn->isKind(ParseNodeKind::StatementList), nextpn->isArity(PN_LIST));
+        if (nextpn->isKind(ParseNodeKind::StatementList) && nextpn->pn_head)
             nextpn = nextpn->pn_head;
         if (!updateSourceCoordNotes(nextpn->pn_pos.begin))
             return false;
     }
 
     *top = { offset() };
     return emit1(JSOP_LOOPHEAD);
 }
 
 bool
 BytecodeEmitter::emitLoopEntry(ParseNode* nextpn, JumpList entryJump)
 {
     if (nextpn) {
         /* Update the line number, as for LOOPHEAD. */
-        if (nextpn->isKind(ParseNodeKind::PNK_LEXICALSCOPE))
+        if (nextpn->isKind(ParseNodeKind::LexicalScope))
             nextpn = nextpn->scopeBody();
-        MOZ_ASSERT_IF(nextpn->isKind(ParseNodeKind::PNK_STATEMENTLIST), nextpn->isArity(PN_LIST));
-        if (nextpn->isKind(ParseNodeKind::PNK_STATEMENTLIST) && nextpn->pn_head)
+        MOZ_ASSERT_IF(nextpn->isKind(ParseNodeKind::StatementList), nextpn->isArity(PN_LIST));
+        if (nextpn->isKind(ParseNodeKind::StatementList) && nextpn->pn_head)
             nextpn = nextpn->pn_head;
         if (!updateSourceCoordNotes(nextpn->pn_pos.begin))
             return false;
     }
 
     JumpTarget entry{ offset() };
     patchJumpsToTarget(entryJump, entry);
 
@@ -2998,22 +2998,22 @@ BytecodeEmitter::emitEnvCoordOp(JSOp op,
     pc += ENVCOORD_SLOT_LEN;
     checkTypeSet(op);
     return true;
 }
 
 static JSOp
 GetIncDecInfo(ParseNodeKind kind, bool* post)
 {
-    MOZ_ASSERT(kind == ParseNodeKind::PNK_POSTINCREMENT ||
-               kind == ParseNodeKind::PNK_PREINCREMENT ||
-               kind == ParseNodeKind::PNK_POSTDECREMENT ||
-               kind == ParseNodeKind::PNK_PREDECREMENT);
-    *post = kind == ParseNodeKind::PNK_POSTINCREMENT || kind == ParseNodeKind::PNK_POSTDECREMENT;
-    return (kind == ParseNodeKind::PNK_POSTINCREMENT || kind == ParseNodeKind::PNK_PREINCREMENT)
+    MOZ_ASSERT(kind == ParseNodeKind::PostIncrement ||
+               kind == ParseNodeKind::PreIncrement ||
+               kind == ParseNodeKind::PostDecrement ||
+               kind == ParseNodeKind::PreDecrement);
+    *post = kind == ParseNodeKind::PostIncrement || kind == ParseNodeKind::PostDecrement;
+    return (kind == ParseNodeKind::PostIncrement || kind == ParseNodeKind::PreIncrement)
            ? JSOP_ADD
            : JSOP_SUB;
 }
 
 JSOp
 BytecodeEmitter::strictifySetNameOp(JSOp op)
 {
     switch (op) {
@@ -3035,434 +3035,434 @@ BytecodeEmitter::checkSideEffects(ParseN
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
  restart:
 
     switch (pn->getKind()) {
       // Trivial cases with no side effects.
-      case ParseNodeKind::PNK_NOP:
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_REGEXP:
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
-      case ParseNodeKind::PNK_ELISION:
-      case ParseNodeKind::PNK_GENERATOR:
-      case ParseNodeKind::PNK_NUMBER:
-      case ParseNodeKind::PNK_OBJECT_PROPERTY_NAME:
+      case ParseNodeKind::Nop:
+      case ParseNodeKind::String:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::RegExp:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
+      case ParseNodeKind::Elision:
+      case ParseNodeKind::Generator:
+      case ParseNodeKind::Number:
+      case ParseNodeKind::ObjectPropertyName:
         MOZ_ASSERT(pn->isArity(PN_NULLARY));
         *answer = false;
         return true;
 
       // |this| can throw in derived class constructors, including nested arrow
       // functions or eval.
-      case ParseNodeKind::PNK_THIS:
+      case ParseNodeKind::This:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = sc->needsThisTDZChecks();
         return true;
 
       // Trivial binary nodes with more token pos holders.
-      case ParseNodeKind::PNK_NEWTARGET:
+      case ParseNodeKind::NewTarget:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
-        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_POSHOLDER));
-        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_POSHOLDER));
+        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PosHolder));
+        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PosHolder));
         *answer = false;
         return true;
 
-      case ParseNodeKind::PNK_BREAK:
-      case ParseNodeKind::PNK_CONTINUE:
-      case ParseNodeKind::PNK_DEBUGGER:
+      case ParseNodeKind::Break:
+      case ParseNodeKind::Continue:
+      case ParseNodeKind::Debugger:
         MOZ_ASSERT(pn->isArity(PN_NULLARY));
         *answer = true;
         return true;
 
       // Watch out for getters!
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         MOZ_ASSERT(pn->isArity(PN_NAME));
         *answer = true;
         return true;
 
       // Unary cases with side effects only if the child has them.
-      case ParseNodeKind::PNK_TYPEOFEXPR:
-      case ParseNodeKind::PNK_VOID:
-      case ParseNodeKind::PNK_NOT:
+      case ParseNodeKind::TypeOfExpr:
+      case ParseNodeKind::Void:
+      case ParseNodeKind::Not:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         return checkSideEffects(pn->pn_kid, answer);
 
       // Even if the name expression is effect-free, performing ToPropertyKey on
       // it might not be effect-free:
       //
       //   RegExp.prototype.toString = () => { throw 42; };
       //   ({ [/regex/]: 0 }); // ToPropertyKey(/regex/) throws 42
       //
       //   function Q() {
       //     ({ [new.target]: 0 });
       //   }
       //   Q.toString = () => { throw 17; };
       //   new Q; // new.target will be Q, ToPropertyKey(Q) throws 17
-      case ParseNodeKind::PNK_COMPUTED_NAME:
+      case ParseNodeKind::ComputedName:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // Looking up or evaluating the associated name could throw.
-      case ParseNodeKind::PNK_TYPEOFNAME:
+      case ParseNodeKind::TypeOfName:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // This unary case has side effects on the enclosing object, sure.  But
       // that's not the question this function answers: it's whether the
       // operation may have a side effect on something *other* than the result
       // of the overall operation in which it's embedded.  The answer to that
       // is no, because an object literal having a mutated prototype only
       // produces a value, without affecting anything else.
-      case ParseNodeKind::PNK_MUTATEPROTO:
+      case ParseNodeKind::MutateProto:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         return checkSideEffects(pn->pn_kid, answer);
 
       // Unary cases with obvious side effects.
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
-      case ParseNodeKind::PNK_THROW:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PreDecrement:
+      case ParseNodeKind::PostDecrement:
+      case ParseNodeKind::Throw:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // These might invoke valueOf/toString, even with a subexpression without
       // side effects!  Consider |+{ valueOf: null, toString: null }|.
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_NEG:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Neg:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // This invokes the (user-controllable) iterator protocol.
-      case ParseNodeKind::PNK_SPREAD:
+      case ParseNodeKind::Spread:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_INITIALYIELD:
-      case ParseNodeKind::PNK_YIELD_STAR:
-      case ParseNodeKind::PNK_YIELD:
-      case ParseNodeKind::PNK_AWAIT:
+      case ParseNodeKind::InitialYield:
+      case ParseNodeKind::YieldStar:
+      case ParseNodeKind::Yield:
+      case ParseNodeKind::Await:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // Deletion generally has side effects, even if isolated cases have none.
-      case ParseNodeKind::PNK_DELETENAME:
-      case ParseNodeKind::PNK_DELETEPROP:
-      case ParseNodeKind::PNK_DELETEELEM:
+      case ParseNodeKind::DeleteName:
+      case ParseNodeKind::DeleteProp:
+      case ParseNodeKind::DeleteElem:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // Deletion of a non-Reference expression has side effects only through
       // evaluating the expression.
-      case ParseNodeKind::PNK_DELETEEXPR: {
+      case ParseNodeKind::DeleteExpr: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         ParseNode* expr = pn->pn_kid;
         return checkSideEffects(expr, answer);
       }
 
-      case ParseNodeKind::PNK_SEMI:
+      case ParseNodeKind::Semi:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (ParseNode* expr = pn->pn_kid)
             return checkSideEffects(expr, answer);
         *answer = false;
         return true;
 
       // Binary cases with obvious side effects.
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
-      case ParseNodeKind::PNK_SETTHIS:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::PowAssign:
+      case ParseNodeKind::SetThis:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_STATEMENTLIST:
+      case ParseNodeKind::StatementList:
       // Strict equality operations and logical operators are well-behaved and
       // perform no conversions.
-      case ParseNodeKind::PNK_OR:
-      case ParseNodeKind::PNK_AND:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_STRICTNE:
+      case ParseNodeKind::Or:
+      case ParseNodeKind::And:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::StrictNe:
       // Any subexpression of a comma expression could be effectful.
-      case ParseNodeKind::PNK_COMMA:
+      case ParseNodeKind::Comma:
         MOZ_ASSERT(pn->pn_count > 0);
         MOZ_FALLTHROUGH;
       // Subcomponents of a literal may be effectful.
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         for (ParseNode* item = pn->pn_head; item; item = item->pn_next) {
             if (!checkSideEffects(item, answer))
                 return false;
             if (*answer)
                 return true;
         }
         return true;
 
       // Most other binary operations (parsed as lists in SpiderMonkey) may
       // perform conversions triggering side effects.  Math operations perform
       // ToNumber and may fail invoking invalid user-defined toString/valueOf:
       // |5 < { toString: null }|.  |instanceof| throws if provided a
       // non-object constructor: |null instanceof null|.  |in| throws if given
       // a non-object RHS: |5 in null|.
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_INSTANCEOF:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_ADD:
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
-      case ParseNodeKind::PNK_POW:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::InstanceOf:
+      case ParseNodeKind::In:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Add:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
+      case ParseNodeKind::Pow:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         MOZ_ASSERT(pn->pn_count >= 2);
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_COLON:
-      case ParseNodeKind::PNK_CASE:
+      case ParseNodeKind::Colon:
+      case ParseNodeKind::Case:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (!checkSideEffects(pn->pn_left, answer))
             return false;
         if (*answer)
             return true;
         return checkSideEffects(pn->pn_right, answer);
 
       // More getters.
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
       // These affect visible names in this code, or in other code.
-      case ParseNodeKind::PNK_IMPORT:
-      case ParseNodeKind::PNK_EXPORT_FROM:
-      case ParseNodeKind::PNK_EXPORT_DEFAULT:
+      case ParseNodeKind::Import:
+      case ParseNodeKind::ExportFrom:
+      case ParseNodeKind::ExportDefault:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
       // Likewise.
-      case ParseNodeKind::PNK_EXPORT:
+      case ParseNodeKind::Export:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         *answer = true;
         return true;
 
       // Every part of a loop might be effect-free, but looping infinitely *is*
       // an effect.  (Language lawyer trivia: C++ says threads can be assumed
       // to exit or have side effects, C++14 [intro.multithread]p27, so a C++
       // implementation's equivalent of the below could set |*answer = false;|
       // if all loop sub-nodes set |*answer = false|!)
-      case ParseNodeKind::PNK_DOWHILE:
-      case ParseNodeKind::PNK_WHILE:
-      case ParseNodeKind::PNK_FOR:
+      case ParseNodeKind::DoWhile:
+      case ParseNodeKind::While:
+      case ParseNodeKind::For:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
       // Declarations affect the name set of the relevant scope.
-      case ParseNodeKind::PNK_VAR:
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET:
+      case ParseNodeKind::Var:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_IF:
-      case ParseNodeKind::PNK_CONDITIONAL:
+      case ParseNodeKind::If:
+      case ParseNodeKind::Conditional:
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         if (!checkSideEffects(pn->pn_kid1, answer))
             return false;
         if (*answer)
             return true;
         if (!checkSideEffects(pn->pn_kid2, answer))
             return false;
         if (*answer)
             return true;
         if ((pn = pn->pn_kid3))
             goto restart;
         return true;
 
       // Function calls can invoke non-local code.
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
-      case ParseNodeKind::PNK_SUPERCALL:
+      case ParseNodeKind::New:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::TaggedTemplate:
+      case ParseNodeKind::SuperCall:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_PIPELINE:
+      case ParseNodeKind::Pipeline:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         MOZ_ASSERT(pn->pn_count >= 2);
         *answer = true;
         return true;
 
       // Classes typically introduce names.  Even if no name is introduced,
       // the heritage and/or class body (through computed property names)
       // usually have effects.
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         *answer = true;
         return true;
 
       // |with| calls |ToObject| on its expression and so throws if that value
       // is null/undefined.
-      case ParseNodeKind::PNK_WITH:
+      case ParseNodeKind::With:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_RETURN:
+      case ParseNodeKind::Return:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Name:
         MOZ_ASSERT(pn->isArity(PN_NAME));
         *answer = true;
         return true;
 
       // Shorthands could trigger getters: the |x| in the object literal in
       // |with ({ get x() { throw 42; } }) ({ x });|, for example, triggers
       // one.  (Of course, it isn't necessary to use |with| for a shorthand to
       // trigger a getter.)
-      case ParseNodeKind::PNK_SHORTHAND:
+      case ParseNodeKind::Shorthand:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         MOZ_ASSERT(pn->isArity(PN_CODE));
         /*
          * A named function, contrary to ES3, is no longer effectful, because
          * we bind its name lexically (using JSOP_CALLEE) instead of creating
          * an Object instance and binding a readonly, permanent property in it
          * (the object and binding can be detected and hijacked or captured).
          * This is a bug fix to ES3; it is fixed in ES3.1 drafts.
          */
         *answer = false;
         return true;
 
-      case ParseNodeKind::PNK_MODULE:
+      case ParseNodeKind::Module:
         *answer = false;
         return true;
 
-      case ParseNodeKind::PNK_TRY:
+      case ParseNodeKind::Try:
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         if (!checkSideEffects(pn->pn_kid1, answer))
             return false;
         if (*answer)
             return true;
         if (ParseNode* catchScope = pn->pn_kid2) {
-            MOZ_ASSERT(catchScope->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+            MOZ_ASSERT(catchScope->isKind(ParseNodeKind::LexicalScope));
             if (!checkSideEffects(catchScope, answer))
                 return false;
             if (*answer)
                 return true;
         }
         if (ParseNode* finallyBlock = pn->pn_kid3) {
             if (!checkSideEffects(finallyBlock, answer))
                 return false;
         }
         return true;
 
-      case ParseNodeKind::PNK_CATCH:
+      case ParseNodeKind::Catch:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (ParseNode* name = pn->pn_left) {
             if (!checkSideEffects(name, answer))
                 return false;
             if (*answer)
                 return true;
         }
         return checkSideEffects(pn->pn_right, answer);
 
-      case ParseNodeKind::PNK_SWITCH:
+      case ParseNodeKind::Switch:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (!checkSideEffects(pn->pn_left, answer))
             return false;
         return *answer || checkSideEffects(pn->pn_right, answer);
 
-      case ParseNodeKind::PNK_LABEL:
+      case ParseNodeKind::Label:
         MOZ_ASSERT(pn->isArity(PN_NAME));
         return checkSideEffects(pn->expr(), answer);
 
-      case ParseNodeKind::PNK_LEXICALSCOPE:
+      case ParseNodeKind::LexicalScope:
         MOZ_ASSERT(pn->isArity(PN_SCOPE));
         return checkSideEffects(pn->scopeBody(), answer);
 
       // We could methodically check every interpolated expression, but it's
       // probably not worth the trouble.  Treat template strings as effect-free
       // only if they don't contain any substitutions.
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
+      case ParseNodeKind::TemplateStringList:
         MOZ_ASSERT(pn->isArity(PN_LIST));
         MOZ_ASSERT(pn->pn_count > 0);
         MOZ_ASSERT((pn->pn_count % 2) == 1,
                    "template strings must alternate template and substitution "
                    "parts");
         *answer = pn->pn_count > 1;
         return true;
 
       // This should be unreachable but is left as-is for now.
-      case ParseNodeKind::PNK_PARAMSBODY:
+      case ParseNodeKind::ParamsBody:
         *answer = true;
         return true;
 
-      case ParseNodeKind::PNK_FORIN:           // by ParseNodeKind::PNK_FOR
-      case ParseNodeKind::PNK_FOROF:           // by ParseNodeKind::PNK_FOR
-      case ParseNodeKind::PNK_FORHEAD:         // by ParseNodeKind::PNK_FOR
-      case ParseNodeKind::PNK_CLASSMETHOD:     // by ParseNodeKind::PNK_CLASS
-      case ParseNodeKind::PNK_CLASSNAMES:      // by ParseNodeKind::PNK_CLASS
-      case ParseNodeKind::PNK_CLASSMETHODLIST: // by ParseNodeKind::PNK_CLASS
-      case ParseNodeKind::PNK_IMPORT_SPEC_LIST: // by ParseNodeKind::PNK_IMPORT
-      case ParseNodeKind::PNK_IMPORT_SPEC:      // by ParseNodeKind::PNK_IMPORT
-      case ParseNodeKind::PNK_EXPORT_BATCH_SPEC:// by ParseNodeKind::PNK_EXPORT
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST: // by ParseNodeKind::PNK_EXPORT
-      case ParseNodeKind::PNK_EXPORT_SPEC:      // by ParseNodeKind::PNK_EXPORT
-      case ParseNodeKind::PNK_CALLSITEOBJ:      // by ParseNodeKind::PNK_TAGGED_TEMPLATE
-      case ParseNodeKind::PNK_POSHOLDER:        // by ParseNodeKind::PNK_NEWTARGET
-      case ParseNodeKind::PNK_SUPERBASE:        // by ParseNodeKind::PNK_ELEM and others
+      case ParseNodeKind::ForIn:           // by ParseNodeKind::For
+      case ParseNodeKind::ForOf:           // by ParseNodeKind::For
+      case ParseNodeKind::ForHead:         // by ParseNodeKind::For
+      case ParseNodeKind::ClassMethod:     // by ParseNodeKind::Class
+      case ParseNodeKind::ClassNames:      // by ParseNodeKind::Class
+      case ParseNodeKind::ClassMethodList: // by ParseNodeKind::Class
+      case ParseNodeKind::ImportSpecList: // by ParseNodeKind::Import
+      case ParseNodeKind::ImportSpec:      // by ParseNodeKind::Import
+      case ParseNodeKind::ExportBatchSpec:// by ParseNodeKind::Export
+      case ParseNodeKind::ExportSpecList: // by ParseNodeKind::Export
+      case ParseNodeKind::ExportSpec:      // by ParseNodeKind::Export
+      case ParseNodeKind::CallSiteObj:      // by ParseNodeKind::TaggedTemplate
+      case ParseNodeKind::PosHolder:        // by ParseNodeKind::NewTarget
+      case ParseNodeKind::SuperBase:        // by ParseNodeKind::Elem and others
         MOZ_CRASH("handled by parent nodes");
 
-      case ParseNodeKind::PNK_LIMIT: // invalid sentinel value
+      case ParseNodeKind::Limit: // invalid sentinel value
         MOZ_CRASH("invalid node kind");
     }
 
     MOZ_CRASH("invalid, unenumerated ParseNodeKind value encountered in "
               "BytecodeEmitter::checkSideEffects");
 }
 
 bool
@@ -3934,35 +3934,35 @@ BytecodeEmitter::emitTDZCheckIfNeeded(JS
     }
 
     return innermostTDZCheckCache->noteTDZCheck(this, name, DontCheckTDZ);
 }
 
 bool
 BytecodeEmitter::emitPropLHS(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_DOT));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Dot));
     MOZ_ASSERT(!pn->as<PropertyAccess>().isSuper());
 
     ParseNode* pn2 = pn->pn_expr;
 
     /*
      * If the object operand is also a dotted property reference, reverse the
      * list linked via pn_expr temporarily so we can iterate over it from the
      * bottom up (reversing again as we go), to avoid excessive recursion.
      */
-    if (pn2->isKind(ParseNodeKind::PNK_DOT) && !pn2->as<PropertyAccess>().isSuper()) {
+    if (pn2->isKind(ParseNodeKind::Dot) && !pn2->as<PropertyAccess>().isSuper()) {
         ParseNode* pndot = pn2;
         ParseNode* pnup = nullptr;
         ParseNode* pndown;
         for (;;) {
             /* Reverse pndot->pn_expr to point up, not down. */
             pndown = pndot->pn_expr;
             pndot->pn_expr = pnup;
-            if (!pndown->isKind(ParseNodeKind::PNK_DOT) || pndown->as<PropertyAccess>().isSuper())
+            if (!pndown->isKind(ParseNodeKind::Dot) || pndown->as<PropertyAccess>().isSuper())
                 break;
             pnup = pndot;
             pndot = pndown;
         }
 
         /* pndown is a primary expression, not a dotted property reference. */
         if (!emitTree(pndown))
             return false;
@@ -4030,17 +4030,17 @@ BytecodeEmitter::emitSuperPropOp(ParseNo
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitPropIncDec(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_DOT));
+    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Dot));
 
     bool post;
     bool isSuper = pn->pn_kid->as<PropertyAccess>().isSuper();
     JSOp binop = GetIncDecInfo(pn->getKind(), &post);
 
     if (isSuper) {
         ParseNode* base = &pn->pn_kid->as<PropertyAccess>().expression();
         if (!emitSuperPropLHS(base))                // THIS OBJ
@@ -4108,17 +4108,17 @@ BytecodeEmitter::emitGetNameAtLocationFo
     }
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitNameIncDec(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Name));
 
     bool post;
     JSOp binop = GetIncDecInfo(pn->getKind(), &post);
 
     auto emitRhs = [pn, post, binop](BytecodeEmitter* bce, const NameLocation& loc,
                                      bool emittedBindOp)
     {
         JSAtom* name = pn->pn_kid->name();
@@ -4179,17 +4179,17 @@ BytecodeEmitter::emitElemOperands(ParseN
             return false;
     }
     return true;
 }
 
 bool
 BytecodeEmitter::emitSuperElemOperands(ParseNode* pn, EmitElemOption opts)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_ELEM) && pn->as<PropertyByValue>().isSuper());
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Elem) && pn->as<PropertyByValue>().isSuper());
 
     // The ordering here is somewhat screwy. We need to evaluate the propval
     // first, by spec. Do a little dance to not emit more than one JSOP_THIS.
     // Since JSOP_THIS might throw in derived class constructors, we cannot
     // just push it earlier as the receiver. We have to swap it down instead.
 
     if (!emitTree(pn->pn_right))
         return false;
@@ -4262,17 +4262,17 @@ BytecodeEmitter::emitSuperElemOp(ParseNo
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitElemIncDec(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_ELEM));
+    MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Elem));
 
     bool isSuper = pn->pn_kid->as<PropertyByValue>().isSuper();
 
     // We need to convert the key to an object id first, so that we do not do
     // it inside both the GETELEM and the SETELEM. This is done by
     // emit(Super)ElemOperands.
     if (isSuper) {
         if (!emitSuperElemOperands(pn->pn_kid, EmitElemOption::IncDec))
@@ -4336,22 +4336,22 @@ BytecodeEmitter::emitElemIncDec(ParseNod
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitCallIncDec(ParseNode* incDec)
 {
-    MOZ_ASSERT(incDec->isKind(ParseNodeKind::PNK_PREINCREMENT) ||
-               incDec->isKind(ParseNodeKind::PNK_POSTINCREMENT) ||
-               incDec->isKind(ParseNodeKind::PNK_PREDECREMENT) ||
-               incDec->isKind(ParseNodeKind::PNK_POSTDECREMENT));
-
-    MOZ_ASSERT(incDec->pn_kid->isKind(ParseNodeKind::PNK_CALL));
+    MOZ_ASSERT(incDec->isKind(ParseNodeKind::PreIncrement) ||
+               incDec->isKind(ParseNodeKind::PostIncrement) ||
+               incDec->isKind(ParseNodeKind::PreDecrement) ||
+               incDec->isKind(ParseNodeKind::PostDecrement));
+
+    MOZ_ASSERT(incDec->pn_kid->isKind(ParseNodeKind::Call));
 
     ParseNode* call = incDec->pn_kid;
     if (!emitTree(call))                                // CALLRESULT
         return false;
     if (!emit1(JSOP_POS))                               // N
         return false;
 
     // The increment/decrement has no side effects, so proceed to throw for
@@ -4399,28 +4399,28 @@ BytecodeEmitter::emitNumberOp(double dva
  * Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047.
  * LLVM is deciding to inline this function which uses a lot of stack space
  * into emitTree which is recursive and uses relatively little stack space.
  */
 MOZ_NEVER_INLINE bool
 BytecodeEmitter::emitSwitch(ParseNode* pn)
 {
     ParseNode* cases = pn->pn_right;
-    MOZ_ASSERT(cases->isKind(ParseNodeKind::PNK_LEXICALSCOPE) ||
-               cases->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+    MOZ_ASSERT(cases->isKind(ParseNodeKind::LexicalScope) ||
+               cases->isKind(ParseNodeKind::StatementList));
 
     // Emit code for the discriminant.
     if (!emitTree(pn->pn_left))
         return false;
 
     // Enter the scope before pushing the switch BreakableControl since all
     // breaks are under this scope.
     Maybe<TDZCheckCache> tdzCache;
     Maybe<EmitterScope> emitterScope;
-    if (cases->isKind(ParseNodeKind::PNK_LEXICALSCOPE)) {
+    if (cases->isKind(ParseNodeKind::LexicalScope)) {
         if (!cases->isEmptyScope()) {
             tdzCache.emplace(this);
             emitterScope.emplace(this);
             if (!emitterScope->enterLexical(this, ScopeKind::Lexical, cases->scopeBindings()))
                 return false;
         }
 
         // Advance |cases| to refer to the switch case list.
@@ -4480,17 +4480,17 @@ BytecodeEmitter::emitSwitch(ParseNode* p
 
             if (switchOp == JSOP_CONDSWITCH)
                 continue;
 
             MOZ_ASSERT(switchOp == JSOP_TABLESWITCH);
 
             ParseNode* caseValue = caseNode->caseExpression();
 
-            if (caseValue->getKind() != ParseNodeKind::PNK_NUMBER) {
+            if (caseValue->getKind() != ParseNodeKind::Number) {
                 switchOp = JSOP_CONDSWITCH;
                 continue;
             }
 
             int32_t i;
             if (!NumberIsInt32(caseValue->pn_dval, &i)) {
                 switchOp = JSOP_CONDSWITCH;
                 continue;
@@ -4642,17 +4642,17 @@ BytecodeEmitter::emitSwitch(ParseNode* p
         pc += JUMP_OFFSET_LEN;
 
         if (tableLength != 0) {
             if (!table.growBy(tableLength))
                 return false;
 
             for (CaseClause* caseNode = firstCase; caseNode; caseNode = caseNode->next()) {
                 if (ParseNode* caseValue = caseNode->caseExpression()) {
-                    MOZ_ASSERT(caseValue->isKind(ParseNodeKind::PNK_NUMBER));
+                    MOZ_ASSERT(caseValue->isKind(ParseNodeKind::Number));
 
                     int32_t i = int32_t(caseValue->pn_dval);
                     MOZ_ASSERT(double(i) == caseValue->pn_dval);
 
                     i -= low;
                     MOZ_ASSERT(uint32_t(i) < tableLength);
                     MOZ_ASSERT(!table[i]);
                     table[i] = caseNode;
@@ -4788,21 +4788,21 @@ BytecodeEmitter::emitYieldOp(JSOp op)
         return false;
 
     return emit1(JSOP_DEBUGAFTERYIELD);
 }
 
 bool
 BytecodeEmitter::emitSetThis(ParseNode* pn)
 {
-    // ParseNodeKind::PNK_SETTHIS is used to update |this| after a super() call
+    // ParseNodeKind::SetThis is used to update |this| after a super() call
     // in a derived class constructor.
 
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_SETTHIS));
-    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::SetThis));
+    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::Name));
 
     RootedAtom name(cx, pn->pn_left->name());
     auto emitRhs = [&name, pn](BytecodeEmitter* bce, const NameLocation&, bool) {
         // Emit the new |this| value.
         if (!bce->emitTree(pn->pn_right))
             return false;
         // Get the original |this| and throw if we already initialized
         // it. Do *not* use the NameLocation argument, as that's the special
@@ -4855,17 +4855,17 @@ BytecodeEmitter::emitScript(ParseNode* b
         MOZ_ASSERT(sc->isModuleContext());
         if (!emitterScope.enterModule(this, sc->asModuleContext()))
             return false;
     }
 
     setFunctionBodyEndPos(body->pn_pos);
 
     if (sc->isEvalContext() && !sc->strict() &&
-        body->isKind(ParseNodeKind::PNK_LEXICALSCOPE) && !body->isEmptyScope())
+        body->isKind(ParseNodeKind::LexicalScope) && !body->isEmptyScope())
     {
         // Sloppy eval scripts may need to emit DEFFUNs in the prologue. If there is
         // an immediately enclosed lexical scope, we need to enter the lexical
         // scope in the prologue for the DEFFUNs to pick up the right
         // environment chain.
         EmitterScope lexicalEmitterScope(this);
 
         switchToPrologue();
@@ -4974,113 +4974,113 @@ BytecodeEmitter::emitFunctionScript(Pars
 
     return true;
 }
 
 template <typename NameEmitter>
 bool
 BytecodeEmitter::emitDestructuringDeclsWithEmitter(ParseNode* pattern, NameEmitter emitName)
 {
-    if (pattern->isKind(ParseNodeKind::PNK_ARRAY)) {
+    if (pattern->isKind(ParseNodeKind::Array)) {
         for (ParseNode* element = pattern->pn_head; element; element = element->pn_next) {
-            if (element->isKind(ParseNodeKind::PNK_ELISION))
+            if (element->isKind(ParseNodeKind::Elision))
                 continue;
             ParseNode* target = element;
-            if (element->isKind(ParseNodeKind::PNK_SPREAD)) {
+            if (element->isKind(ParseNodeKind::Spread)) {
                 target = element->pn_kid;
             }
-            if (target->isKind(ParseNodeKind::PNK_ASSIGN))
+            if (target->isKind(ParseNodeKind::Assign))
                 target = target->pn_left;
-            if (target->isKind(ParseNodeKind::PNK_NAME)) {
+            if (target->isKind(ParseNodeKind::Name)) {
                 if (!emitName(this, target))
                     return false;
             } else {
                 if (!emitDestructuringDeclsWithEmitter(target, emitName))
                     return false;
             }
         }
         return true;
     }
 
-    MOZ_ASSERT(pattern->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(pattern->isKind(ParseNodeKind::Object));
     for (ParseNode* member = pattern->pn_head; member; member = member->pn_next) {
-        MOZ_ASSERT(member->isKind(ParseNodeKind::PNK_MUTATEPROTO) ||
-                   member->isKind(ParseNodeKind::PNK_COLON) ||
-                   member->isKind(ParseNodeKind::PNK_SHORTHAND));
-
-        ParseNode* target = member->isKind(ParseNodeKind::PNK_MUTATEPROTO)
+        MOZ_ASSERT(member->isKind(ParseNodeKind::MutateProto) ||
+                   member->isKind(ParseNodeKind::Colon) ||
+                   member->isKind(ParseNodeKind::Shorthand));
+
+        ParseNode* target = member->isKind(ParseNodeKind::MutateProto)
                             ? member->pn_kid
                             : member->pn_right;
 
-        if (target->isKind(ParseNodeKind::PNK_ASSIGN))
+        if (target->isKind(ParseNodeKind::Assign))
             target = target->pn_left;
-        if (target->isKind(ParseNodeKind::PNK_NAME)) {
+        if (target->isKind(ParseNodeKind::Name)) {
             if (!emitName(this, target))
                 return false;
         } else {
             if (!emitDestructuringDeclsWithEmitter(target, emitName))
                 return false;
         }
     }
     return true;
 }
 
 bool
 BytecodeEmitter::emitDestructuringLHSRef(ParseNode* target, size_t* emitted)
 {
     *emitted = 0;
 
-    if (target->isKind(ParseNodeKind::PNK_SPREAD))
+    if (target->isKind(ParseNodeKind::Spread))
         target = target->pn_kid;
-    else if (target->isKind(ParseNodeKind::PNK_ASSIGN))
+    else if (target->isKind(ParseNodeKind::Assign))
         target = target->pn_left;
 
-    // No need to recur into ParseNodeKind::PNK_ARRAY and
-    // ParseNodeKind::PNK_OBJECT subpatterns here, since
+    // No need to recur into ParseNodeKind::Array and
+    // ParseNodeKind::Object subpatterns here, since
     // emitSetOrInitializeDestructuring does the recursion when
     // setting or initializing value.  Getting reference doesn't recur.
-    if (target->isKind(ParseNodeKind::PNK_NAME) ||
-        target->isKind(ParseNodeKind::PNK_ARRAY) ||
-        target->isKind(ParseNodeKind::PNK_OBJECT))
+    if (target->isKind(ParseNodeKind::Name) ||
+        target->isKind(ParseNodeKind::Array) ||
+        target->isKind(ParseNodeKind::Object))
     {
         return true;
     }
 
 #ifdef DEBUG
     int depth = stackDepth;
 #endif
 
     switch (target->getKind()) {
-      case ParseNodeKind::PNK_DOT: {
+      case ParseNodeKind::Dot: {
         if (target->as<PropertyAccess>().isSuper()) {
             if (!emitSuperPropLHS(&target->as<PropertyAccess>().expression()))
                 return false;
             *emitted = 2;
         } else {
             if (!emitTree(target->pn_expr))
                 return false;
             *emitted = 1;
         }
         break;
       }
 
-      case ParseNodeKind::PNK_ELEM: {
+      case ParseNodeKind::Elem: {
         if (target->as<PropertyByValue>().isSuper()) {
             if (!emitSuperElemOperands(target, EmitElemOption::Ref))
                 return false;
             *emitted = 3;
         } else {
             if (!emitElemOperands(target, EmitElemOption::Ref))
                 return false;
             *emitted = 2;
         }
         break;
       }
 
-      case ParseNodeKind::PNK_CALL:
+      case ParseNodeKind::Call:
         MOZ_ASSERT_UNREACHABLE("Parser::reportIfNotValidSimpleAssignmentTarget "
                                "rejects function calls as assignment "
                                "targets in destructuring assignments");
         break;
 
       default:
         MOZ_CRASH("emitDestructuringLHSRef: bad lhs kind");
     }
@@ -5092,30 +5092,30 @@ BytecodeEmitter::emitDestructuringLHSRef
 
 bool
 BytecodeEmitter::emitSetOrInitializeDestructuring(ParseNode* target, DestructuringFlavor flav)
 {
     // Now emit the lvalue opcode sequence. If the lvalue is a nested
     // destructuring initialiser-form, call ourselves to handle it, then pop
     // the matched value. Otherwise emit an lvalue bytecode sequence followed
     // by an assignment op.
-    if (target->isKind(ParseNodeKind::PNK_SPREAD))
+    if (target->isKind(ParseNodeKind::Spread))
         target = target->pn_kid;
-    else if (target->isKind(ParseNodeKind::PNK_ASSIGN))
+    else if (target->isKind(ParseNodeKind::Assign))
         target = target->pn_left;
-    if (target->isKind(ParseNodeKind::PNK_ARRAY) || target->isKind(ParseNodeKind::PNK_OBJECT)) {
+    if (target->isKind(ParseNodeKind::Array) || target->isKind(ParseNodeKind::Object)) {
         if (!emitDestructuringOps(target, flav))
             return false;
         // Per its post-condition, emitDestructuringOps has left the
         // to-be-destructured value on top of the stack.
         if (!emit1(JSOP_POP))
             return false;
     } else {
         switch (target->getKind()) {
-          case ParseNodeKind::PNK_NAME: {
+          case ParseNodeKind::Name: {
             auto emitSwapScopeAndRhs = [](BytecodeEmitter* bce, const NameLocation&,
                                           bool emittedBindOp)
             {
                 if (emittedBindOp) {
                     // This is like ordinary assignment, but with one
                     // difference.
                     //
                     // In `a = b`, we first determine a binding for `a` (using
@@ -5161,45 +5161,45 @@ BytecodeEmitter::emitSetOrInitializeDest
                 if (!emitSetName(name, emitSwapScopeAndRhs))
                     return false;
                 break;
             }
 
             break;
           }
 
-          case ParseNodeKind::PNK_DOT: {
+          case ParseNodeKind::Dot: {
             // The reference is already pushed by emitDestructuringLHSRef.
             JSOp setOp;
             if (target->as<PropertyAccess>().isSuper())
                 setOp = sc->strict() ? JSOP_STRICTSETPROP_SUPER : JSOP_SETPROP_SUPER;
             else
                 setOp = sc->strict() ? JSOP_STRICTSETPROP : JSOP_SETPROP;
             if (!emitAtomOp(target, setOp))
                 return false;
             break;
           }
 
-          case ParseNodeKind::PNK_ELEM: {
+          case ParseNodeKind::Elem: {
             // The reference is already pushed by emitDestructuringLHSRef.
             if (target->as<PropertyByValue>().isSuper()) {
                 JSOp setOp = sc->strict() ? JSOP_STRICTSETELEM_SUPER : JSOP_SETELEM_SUPER;
                 // emitDestructuringLHSRef already did emitSuperElemOperands
                 // part of emitSuperElemOp.  Perform remaining part here.
                 if (!emitElemOpBase(setOp))
                     return false;
             } else {
                 JSOp setOp = sc->strict() ? JSOP_STRICTSETELEM : JSOP_SETELEM;
                 if (!emitElemOpBase(setOp))
                     return false;
             }
             break;
           }
 
-          case ParseNodeKind::PNK_CALL:
+          case ParseNodeKind::Call:
             MOZ_ASSERT_UNREACHABLE("Parser::reportIfNotValidSimpleAssignmentTarget "
                                    "rejects function calls as assignment "
                                    "targets in destructuring assignments");
             break;
 
           default:
             MOZ_CRASH("emitSetOrInitializeDestructuring: bad lhs kind");
         }
@@ -5460,17 +5460,17 @@ BytecodeEmitter::emitDefault(ParseNode* 
         return false;
     return true;
 }
 
 bool
 BytecodeEmitter::setOrEmitSetFunName(ParseNode* maybeFun, HandleAtom name,
                                      FunctionPrefixKind prefixKind)
 {
-    if (maybeFun->isKind(ParseNodeKind::PNK_FUNCTION)) {
+    if (maybeFun->isKind(ParseNodeKind::Function)) {
         // Function doesn't have 'name' property at this point.
         // Set function's name at compile time.
         JSFunction* fun = maybeFun->pn_funbox->function();
 
         // Single node can be emitted multiple times if it appears in
         // array destructuring default.  If function already has a name,
         // just return.
         if (fun->hasCompileTimeName()) {
@@ -5500,17 +5500,17 @@ BytecodeEmitter::setOrEmitSetFunName(Par
 }
 
 bool
 BytecodeEmitter::emitInitializer(ParseNode* initializer, ParseNode* pattern)
 {
     if (!emitTree(initializer))
         return false;
 
-    if (!pattern->isInParens() && pattern->isKind(ParseNodeKind::PNK_NAME) &&
+    if (!pattern->isInParens() && pattern->isKind(ParseNodeKind::Name) &&
         initializer->isDirectRHSAnonFunction())
     {
         RootedAtom name(cx, pattern->name());
         if (!setOrEmitSetFunName(initializer, name, FunctionPrefixKind::None))
             return false;
     }
 
     return true;
@@ -5521,17 +5521,17 @@ BytecodeEmitter::emitInitializerInBranch
 {
     TDZCheckCache tdzCache(this);
     return emitInitializer(initializer, pattern);
 }
 
 bool
 BytecodeEmitter::emitDestructuringOpsArray(ParseNode* pattern, DestructuringFlavor flav)
 {
-    MOZ_ASSERT(pattern->isKind(ParseNodeKind::PNK_ARRAY));
+    MOZ_ASSERT(pattern->isKind(ParseNodeKind::Array));
     MOZ_ASSERT(pattern->isArity(PN_LIST));
     MOZ_ASSERT(this->stackDepth != 0);
 
     // Here's pseudo code for |let [a, b, , c=y, ...d] = x;|
     //
     // Lines that are annotated "covered by trynote" mean that upon throwing
     // an exception, IteratorClose is called on iter only if done is false.
     //
@@ -5639,20 +5639,20 @@ BytecodeEmitter::emitDestructuringOpsArr
     for (ParseNode* member = pattern->pn_head; member; member = member->pn_next) {
         bool isFirst = member == pattern->pn_head;
         DebugOnly<bool> hasNext = !!member->pn_next;
 
         size_t emitted = 0;
 
         // Spec requires LHS reference to be evaluated first.
         ParseNode* lhsPattern = member;
-        if (lhsPattern->isKind(ParseNodeKind::PNK_ASSIGN))
+        if (lhsPattern->isKind(ParseNodeKind::Assign))
             lhsPattern = lhsPattern->pn_left;
 
-        bool isElision = lhsPattern->isKind(ParseNodeKind::PNK_ELISION);
+        bool isElision = lhsPattern->isKind(ParseNodeKind::Elision);
         if (!isElision) {
             auto emitLHSRef = [lhsPattern, &emitted](BytecodeEmitter* bce) {
                 return bce->emitDestructuringLHSRef(lhsPattern, &emitted); // ... OBJ ITER DONE *LREF
             };
             if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth, emitLHSRef))
                 return false;
         }
 
@@ -5666,17 +5666,17 @@ BytecodeEmitter::emitDestructuringOpsArr
             // If this element is the first, DONE is always FALSE, so pop it.
             //
             // Non-first elements should emit if-else depending on the
             // member pattern, below.
             if (!emit1(JSOP_POP))                                 // ... OBJ ITER *LREF
                 return false;
         }
 
-        if (member->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (member->isKind(ParseNodeKind::Spread)) {
             IfThenElseEmitter ifThenElse(this);
             if (!isFirst) {
                 // If spread is not the first element of the pattern,
                 // iterator can already be completed.
                                                                   // ... OBJ ITER *LREF DONE
                 if (!ifThenElse.emitIfElse())                     // ... OBJ ITER *LREF
                     return false;
 
@@ -5717,20 +5717,20 @@ BytecodeEmitter::emitDestructuringOpsArr
             if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth, emitAssignment))
                 return false;
 
             MOZ_ASSERT(!hasNext);
             break;
         }
 
         ParseNode* pndefault = nullptr;
-        if (member->isKind(ParseNodeKind::PNK_ASSIGN))
+        if (member->isKind(ParseNodeKind::Assign))
             pndefault = member->pn_right;
 
-        MOZ_ASSERT(!member->isKind(ParseNodeKind::PNK_SPREAD));
+        MOZ_ASSERT(!member->isKind(ParseNodeKind::Spread));
 
         IfThenElseEmitter ifAlreadyDone(this);
         if (!isFirst) {
                                                                   // ... OBJ ITER *LREF DONE
             if (!ifAlreadyDone.emitIfElse())                      // ... OBJ ITER *LREF
                 return false;
 
             if (!emit1(JSOP_UNDEFINED))                           // ... OBJ ITER *LREF UNDEF
@@ -5827,66 +5827,66 @@ BytecodeEmitter::emitDestructuringOpsArr
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitComputedPropertyName(ParseNode* computedPropName)
 {
-    MOZ_ASSERT(computedPropName->isKind(ParseNodeKind::PNK_COMPUTED_NAME));
+    MOZ_ASSERT(computedPropName->isKind(ParseNodeKind::ComputedName));
     return emitTree(computedPropName->pn_kid) && emit1(JSOP_TOID);
 }
 
 bool
 BytecodeEmitter::emitDestructuringOpsObject(ParseNode* pattern, DestructuringFlavor flav)
 {
-    MOZ_ASSERT(pattern->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(pattern->isKind(ParseNodeKind::Object));
     MOZ_ASSERT(pattern->isArity(PN_LIST));
 
     MOZ_ASSERT(this->stackDepth > 0);                             // ... RHS
 
     if (!emit1(JSOP_CHECKOBJCOERCIBLE))                           // ... RHS
         return false;
 
     bool needsRestPropertyExcludedSet = pattern->pn_count > 1 &&
-                                        pattern->last()->isKind(ParseNodeKind::PNK_SPREAD);
+                                        pattern->last()->isKind(ParseNodeKind::Spread);
     if (needsRestPropertyExcludedSet) {
         if (!emitDestructuringObjRestExclusionSet(pattern))       // ... RHS SET
             return false;
 
         if (!emit1(JSOP_SWAP))                                    // ... SET RHS
             return false;
     }
 
     for (ParseNode* member = pattern->pn_head; member; member = member->pn_next) {
         ParseNode* subpattern;
-        if (member->isKind(ParseNodeKind::PNK_MUTATEPROTO) ||
-            member->isKind(ParseNodeKind::PNK_SPREAD))
+        if (member->isKind(ParseNodeKind::MutateProto) ||
+            member->isKind(ParseNodeKind::Spread))
         {
             subpattern = member->pn_kid;
         } else {
             subpattern = member->pn_right;
         }
 
         ParseNode* lhs = subpattern;
-        MOZ_ASSERT_IF(member->isKind(ParseNodeKind::PNK_SPREAD),
-                      !lhs->isKind(ParseNodeKind::PNK_ASSIGN));
-        if (lhs->isKind(ParseNodeKind::PNK_ASSIGN))
+        MOZ_ASSERT_IF(member->isKind(ParseNodeKind::Spread),
+                      !lhs->isKind(ParseNodeKind::Assign));
+        if (lhs->isKind(ParseNodeKind::Assign))
             lhs = lhs->pn_left;
 
         size_t emitted;
         if (!emitDestructuringLHSRef(lhs, &emitted))              // ... *SET RHS *LREF
             return false;
 
         // Duplicate the value being destructured to use as a reference base.
         if (!emitDupAt(emitted))                                  // ... *SET RHS *LREF RHS
             return false;
 
-        if (member->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (member->isKind(ParseNodeKind::Spread)) {
             if (!updateSourceCoordNotes(member->pn_pos.begin))
                 return false;
 
             if (!emitNewInit(JSProto_Object))                     // ... *SET RHS *LREF RHS TARGET
                 return false;
             if (!emit1(JSOP_DUP))                                 // ... *SET RHS *LREF RHS TARGET TARGET
                 return false;
             if (!emit2(JSOP_PICK, 2))                             // ... *SET RHS *LREF TARGET TARGET RHS
@@ -5911,30 +5911,30 @@ BytecodeEmitter::emitDestructuringOpsObj
             break;
         }
 
         // Now push the property name currently being matched, which is the
         // current property name "label" on the left of a colon in the object
         // initialiser.
         bool needsGetElem = true;
 
-        if (member->isKind(ParseNodeKind::PNK_MUTATEPROTO)) {
+        if (member->isKind(ParseNodeKind::MutateProto)) {
             if (!emitAtomOp(cx->names().proto, JSOP_GETPROP))     // ... *SET RHS *LREF PROP
                 return false;
             needsGetElem = false;
         } else {
-            MOZ_ASSERT(member->isKind(ParseNodeKind::PNK_COLON) ||
-                       member->isKind(ParseNodeKind::PNK_SHORTHAND));
+            MOZ_ASSERT(member->isKind(ParseNodeKind::Colon) ||
+                       member->isKind(ParseNodeKind::Shorthand));
 
             ParseNode* key = member->pn_left;
-            if (key->isKind(ParseNodeKind::PNK_NUMBER)) {
+            if (key->isKind(ParseNodeKind::Number)) {
                 if (!emitNumberOp(key->pn_dval))                  // ... *SET RHS *LREF RHS KEY
                     return false;
-            } else if (key->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                       key->isKind(ParseNodeKind::PNK_STRING))
+            } else if (key->isKind(ParseNodeKind::ObjectPropertyName) ||
+                       key->isKind(ParseNodeKind::String))
             {
                 if (!emitAtomOp(key->pn_atom, JSOP_GETPROP))      // ... *SET RHS *LREF PROP
                     return false;
                 needsGetElem = false;
             } else {
                 if (!emitComputedPropertyName(key))               // ... *SET RHS *LREF RHS KEY
                     return false;
 
@@ -5953,35 +5953,35 @@ BytecodeEmitter::emitDestructuringOpsObj
                 }
             }
         }
 
         // Get the property value if not done already.
         if (needsGetElem && !emitElemOpBase(JSOP_GETELEM))        // ... *SET RHS *LREF PROP
             return false;
 
-        if (subpattern->isKind(ParseNodeKind::PNK_ASSIGN)) {
+        if (subpattern->isKind(ParseNodeKind::Assign)) {
             if (!emitDefault(subpattern->pn_right, lhs))          // ... *SET RHS *LREF VALUE
                 return false;
         }
 
         // Destructure PROP per this member's lhs.
         if (!emitSetOrInitializeDestructuring(subpattern, flav))  // ... *SET RHS
             return false;
     }
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitDestructuringObjRestExclusionSet(ParseNode* pattern)
 {
-    MOZ_ASSERT(pattern->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(pattern->isKind(ParseNodeKind::Object));
     MOZ_ASSERT(pattern->isArity(PN_LIST));
-    MOZ_ASSERT(pattern->last()->isKind(ParseNodeKind::PNK_SPREAD));
+    MOZ_ASSERT(pattern->last()->isKind(ParseNodeKind::Spread));
 
     ptrdiff_t offset = this->offset();
     if (!emitNewInit(JSProto_Object))
         return false;
 
     // Try to construct the shape of the object as we go, so we can emit a
     // JSOP_NEWOBJECT with the final shape instead.
     // In the case of computed property names and indices, we cannot fix the
@@ -5992,30 +5992,30 @@ BytecodeEmitter::emitDestructuringObjRes
     // bound of how many properties we plan to have.
     gc::AllocKind kind = gc::GetGCObjectKind(pattern->pn_count - 1);
     RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx, kind, TenuredObject));
     if (!obj)
         return false;
 
     RootedAtom pnatom(cx);
     for (ParseNode* member = pattern->pn_head; member; member = member->pn_next) {
-        if (member->isKind(ParseNodeKind::PNK_SPREAD))
+        if (member->isKind(ParseNodeKind::Spread))
             break;
 
         bool isIndex = false;
-        if (member->isKind(ParseNodeKind::PNK_MUTATEPROTO)) {
+        if (member->isKind(ParseNodeKind::MutateProto)) {
             pnatom.set(cx->names().proto);
         } else {
             ParseNode* key = member->pn_left;
-            if (key->isKind(ParseNodeKind::PNK_NUMBER)) {
+            if (key->isKind(ParseNodeKind::Number)) {
                 if (!emitNumberOp(key->pn_dval))
                     return false;
                 isIndex = true;
-            } else if (key->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                       key->isKind(ParseNodeKind::PNK_STRING))
+            } else if (key->isKind(ParseNodeKind::ObjectPropertyName) ||
+                       key->isKind(ParseNodeKind::String))
             {
                 pnatom.set(key->pn_atom);
             } else {
                 // Otherwise this is a computed property name which needs to
                 // be added dynamically.
                 obj.set(nullptr);
                 continue;
             }
@@ -6056,31 +6056,31 @@ BytecodeEmitter::emitDestructuringObjRes
     }
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitDestructuringOps(ParseNode* pattern, DestructuringFlavor flav)
 {
-    if (pattern->isKind(ParseNodeKind::PNK_ARRAY))
+    if (pattern->isKind(ParseNodeKind::Array))
         return emitDestructuringOpsArray(pattern, flav);
     return emitDestructuringOpsObject(pattern, flav);
 }
 
 bool
 BytecodeEmitter::emitTemplateString(ParseNode* pn)
 {
     MOZ_ASSERT(pn->isArity(PN_LIST));
 
     bool pushedString = false;
 
     for (ParseNode* pn2 = pn->pn_head; pn2 != NULL; pn2 = pn2->pn_next) {
-        bool isString = (pn2->getKind() == ParseNodeKind::PNK_STRING ||
-                         pn2->getKind() == ParseNodeKind::PNK_TEMPLATE_STRING);
+        bool isString = (pn2->getKind() == ParseNodeKind::String ||
+                         pn2->getKind() == ParseNodeKind::TemplateString);
 
         // Skip empty strings. These are very common: a template string like
         // `${a}${b}` has three empty strings and without this optimization
         // we'd emit four JSOP_ADD operations instead of just one.
         if (isString && pn2->pn_atom->empty())
             continue;
 
         if (!isString) {
@@ -6124,22 +6124,22 @@ BytecodeEmitter::emitDeclarationList(Par
     MOZ_ASSERT(declList->isOp(JSOP_NOP));
 
     ParseNode* next;
     for (ParseNode* decl = declList->pn_head; decl; decl = next) {
         if (!updateSourceCoordNotes(decl->pn_pos.begin))
             return false;
         next = decl->pn_next;
 
-        if (decl->isKind(ParseNodeKind::PNK_ASSIGN)) {
+        if (decl->isKind(ParseNodeKind::Assign)) {
             MOZ_ASSERT(decl->isOp(JSOP_NOP));
 
             ParseNode* pattern = decl->pn_left;
-            MOZ_ASSERT(pattern->isKind(ParseNodeKind::PNK_ARRAY) ||
-                       pattern->isKind(ParseNodeKind::PNK_OBJECT));
+            MOZ_ASSERT(pattern->isKind(ParseNodeKind::Array) ||
+                       pattern->isKind(ParseNodeKind::Object));
 
             if (!emitTree(decl->pn_right))
                 return false;
 
             if (!emitDestructuringOps(pattern, DestructuringDeclaration))
                 return false;
 
             if (!emit1(JSOP_POP))
@@ -6151,27 +6151,27 @@ BytecodeEmitter::emitDeclarationList(Par
     }
     return true;
 }
 
 bool
 BytecodeEmitter::emitSingleDeclaration(ParseNode* declList, ParseNode* decl,
                                        ParseNode* initializer)
 {
-    MOZ_ASSERT(decl->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(decl->isKind(ParseNodeKind::Name));
 
     // Nothing to do for initializer-less 'var' declarations, as there's no TDZ.
-    if (!initializer && declList->isKind(ParseNodeKind::PNK_VAR))
+    if (!initializer && declList->isKind(ParseNodeKind::Var))
         return true;
 
     auto emitRhs = [initializer, declList, decl](BytecodeEmitter* bce, const NameLocation&, bool) {
         if (!initializer) {
             // Lexical declarations are initialized to undefined without an
             // initializer.
-            MOZ_ASSERT(declList->isKind(ParseNodeKind::PNK_LET),
+            MOZ_ASSERT(declList->isKind(ParseNodeKind::Let),
                        "var declarations without initializers handled above, "
                        "and const declarations must have initializers");
             Unused << declList; // silence clang -Wunused-lambda-capture in opt builds
             return bce->emit1(JSOP_UNDEFINED);
         }
 
         MOZ_ASSERT(initializer);
         return bce->emitInitializer(initializer, decl);
@@ -6200,41 +6200,41 @@ EmitAssignmentRhs(BytecodeEmitter* bce, 
 
     return true;
 }
 
 static inline JSOp
 CompoundAssignmentParseNodeKindToJSOp(ParseNodeKind pnk)
 {
     switch (pnk) {
-      case ParseNodeKind::PNK_ASSIGN:       return JSOP_NOP;
-      case ParseNodeKind::PNK_ADDASSIGN:    return JSOP_ADD;
-      case ParseNodeKind::PNK_SUBASSIGN:    return JSOP_SUB;
-      case ParseNodeKind::PNK_BITORASSIGN:  return JSOP_BITOR;
-      case ParseNodeKind::PNK_BITXORASSIGN: return JSOP_BITXOR;
-      case ParseNodeKind::PNK_BITANDASSIGN: return JSOP_BITAND;
-      case ParseNodeKind::PNK_LSHASSIGN:    return JSOP_LSH;
-      case ParseNodeKind::PNK_RSHASSIGN:    return JSOP_RSH;
-      case ParseNodeKind::PNK_URSHASSIGN:   return JSOP_URSH;
-      case ParseNodeKind::PNK_MULASSIGN:    return JSOP_MUL;
-      case ParseNodeKind::PNK_DIVASSIGN:    return JSOP_DIV;
-      case ParseNodeKind::PNK_MODASSIGN:    return JSOP_MOD;
-      case ParseNodeKind::PNK_POWASSIGN:    return JSOP_POW;
+      case ParseNodeKind::Assign:       return JSOP_NOP;
+      case ParseNodeKind::AddAssign:    return JSOP_ADD;
+      case ParseNodeKind::SubAssign:    return JSOP_SUB;
+      case ParseNodeKind::BitOrAssign:  return JSOP_BITOR;
+      case ParseNodeKind::BitXorAssign: return JSOP_BITXOR;
+      case ParseNodeKind::BitAndAssign: return JSOP_BITAND;
+      case ParseNodeKind::LshAssign:    return JSOP_LSH;
+      case ParseNodeKind::RshAssign:    return JSOP_RSH;
+      case ParseNodeKind::UrshAssign:   return JSOP_URSH;
+      case ParseNodeKind::MulAssign:    return JSOP_MUL;
+      case ParseNodeKind::DivAssign:    return JSOP_DIV;
+      case ParseNodeKind::ModAssign:    return JSOP_MOD;
+      case ParseNodeKind::PowAssign:    return JSOP_POW;
       default: MOZ_CRASH("unexpected compound assignment op");
     }
 }
 
 bool
 BytecodeEmitter::emitAssignment(ParseNode* lhs, ParseNodeKind pnk, ParseNode* rhs)
 {
     JSOp op = CompoundAssignmentParseNodeKindToJSOp(pnk);
 
     // Name assignments are handled separately because choosing ops and when
     // to emit BINDNAME is involved and should avoid duplication.
-    if (lhs->isKind(ParseNodeKind::PNK_NAME)) {
+    if (lhs->isKind(ParseNodeKind::Name)) {
         auto emitRhs = [op, lhs, rhs](BytecodeEmitter* bce, const NameLocation& lhsLoc,
                                       bool emittedBindOp)
         {
             // For compound assignments, first get the LHS value, then emit
             // the RHS and the op.
             if (op != JSOP_NOP) {
                 if (!bce->emitGetNameAtLocationForCompoundAssignment(lhs->name(), lhsLoc))
                     return false;
@@ -6263,47 +6263,47 @@ BytecodeEmitter::emitAssignment(ParseNod
         return emitSetName(lhs, emitRhs);
     }
 
     // Deal with non-name assignments.
     uint32_t atomIndex = (uint32_t) -1;
     uint8_t offset = 1;
 
     switch (lhs->getKind()) {
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         if (lhs->as<PropertyAccess>().isSuper()) {
             if (!emitSuperPropLHS(&lhs->as<PropertyAccess>().expression()))
                 return false;
             offset += 2;
         } else {
             if (!emitTree(lhs->expr()))
                 return false;
             offset += 1;
         }
         if (!makeAtomIndex(lhs->pn_atom, &atomIndex))
             return false;
         break;
-      case ParseNodeKind::PNK_ELEM: {
+      case ParseNodeKind::Elem: {
         MOZ_ASSERT(lhs->isArity(PN_BINARY));
         EmitElemOption opt = op == JSOP_NOP ? EmitElemOption::Get : EmitElemOption::CompoundAssign;
         if (lhs->as<PropertyByValue>().isSuper()) {
             if (!emitSuperElemOperands(lhs, opt))
                 return false;
             offset += 3;
         } else {
             if (!emitElemOperands(lhs, opt))
                 return false;
             offset += 2;
         }
         break;
       }
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
-        break;
-      case ParseNodeKind::PNK_CALL:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
+        break;
+      case ParseNodeKind::Call:
         if (!emitTree(lhs))
             return false;
 
         // Assignment to function calls is forbidden, but we have to make the
         // call first.  Now we can throw.
         if (!emitUint16Operand(JSOP_THROWMSG, JSMSG_BAD_LEFTSIDE_OF_ASS))
             return false;
 
@@ -6313,33 +6313,33 @@ BytecodeEmitter::emitAssignment(ParseNod
         break;
       default:
         MOZ_ASSERT(0);
     }
 
     if (op != JSOP_NOP) {
         MOZ_ASSERT(rhs);
         switch (lhs->getKind()) {
-          case ParseNodeKind::PNK_DOT: {
+          case ParseNodeKind::Dot: {
             JSOp getOp;
             if (lhs->as<PropertyAccess>().isSuper()) {
                 if (!emit1(JSOP_DUP2))
                     return false;
                 getOp = JSOP_GETPROP_SUPER;
             } else {
                 if (!emit1(JSOP_DUP))
                     return false;
                 bool isLength = (lhs->pn_atom == cx->names().length);
                 getOp = isLength ? JSOP_LENGTH : JSOP_GETPROP;
             }
             if (!emitIndex32(getOp, atomIndex))
                 return false;
             break;
           }
-          case ParseNodeKind::PNK_ELEM: {
+          case ParseNodeKind::Elem: {
             JSOp elemOp;
             if (lhs->as<PropertyByValue>().isSuper()) {
                 if (!emitDupAt(2))
                     return false;
                 if (!emitDupAt(2))
                     return false;
                 if (!emitDupAt(2))
                     return false;
@@ -6348,17 +6348,17 @@ BytecodeEmitter::emitAssignment(ParseNod
                 if (!emit1(JSOP_DUP2))
                     return false;
                 elemOp = JSOP_GETELEM;
             }
             if (!emitElemOpBase(elemOp))
                 return false;
             break;
           }
-          case ParseNodeKind::PNK_CALL:
+          case ParseNodeKind::Call:
             // We just emitted a JSOP_THROWMSG and popped the call's return
             // value.  Push a random value to make sure the stack depth is
             // correct.
             if (!emit1(JSOP_NULL))
                 return false;
             break;
           default:;
         }
@@ -6372,37 +6372,37 @@ BytecodeEmitter::emitAssignment(ParseNod
         if (!newSrcNote(SRC_ASSIGNOP))
             return false;
         if (!emit1(op))
             return false;
     }
 
     /* Finally, emit the specialized assignment bytecode. */
     switch (lhs->getKind()) {
-      case ParseNodeKind::PNK_DOT: {
+      case ParseNodeKind::Dot: {
         JSOp setOp = lhs->as<PropertyAccess>().isSuper() ?
                        (sc->strict() ? JSOP_STRICTSETPROP_SUPER : JSOP_SETPROP_SUPER) :
                        (sc->strict() ? JSOP_STRICTSETPROP : JSOP_SETPROP);
         if (!emitIndexOp(setOp, atomIndex))
             return false;
         break;
       }
-      case ParseNodeKind::PNK_CALL:
+      case ParseNodeKind::Call:
         // We threw above, so nothing to do here.
         break;
-      case ParseNodeKind::PNK_ELEM: {
+      case ParseNodeKind::Elem: {
         JSOp setOp = lhs->as<PropertyByValue>().isSuper() ?
                        sc->strict() ? JSOP_STRICTSETELEM_SUPER : JSOP_SETELEM_SUPER :
                        sc->strict() ? JSOP_STRICTSETELEM : JSOP_SETELEM;
         if (!emit1(setOp))
             return false;
         break;
       }
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
         if (!emitDestructuringOps(lhs, DestructuringAssignment))
             return false;
         break;
       default:
         MOZ_ASSERT(0);
     }
     return true;
 }
@@ -6410,52 +6410,52 @@ BytecodeEmitter::emitAssignment(ParseNod
 bool
 ParseNode::getConstantValue(JSContext* cx, AllowConstantObjects allowObjects,
                             MutableHandleValue vp, Value* compare, size_t ncompare,
                             NewObjectKind newKind)
 {
     MOZ_ASSERT(newKind == TenuredObject || newKind == SingletonObject);
 
     switch (getKind()) {
-      case ParseNodeKind::PNK_NUMBER:
+      case ParseNodeKind::Number:
         vp.setNumber(pn_dval);
         return true;
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_STRING:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::String:
         vp.setString(pn_atom);
         return true;
-      case ParseNodeKind::PNK_TRUE:
+      case ParseNodeKind::True:
         vp.setBoolean(true);
         return true;
-      case ParseNodeKind::PNK_FALSE:
+      case ParseNodeKind::False:
         vp.setBoolean(false);
         return true;
-      case ParseNodeKind::PNK_NULL:
+      case ParseNodeKind::Null:
         vp.setNull();
         return true;
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
+      case ParseNodeKind::RawUndefined:
         vp.setUndefined();
         return true;
-      case ParseNodeKind::PNK_CALLSITEOBJ:
-      case ParseNodeKind::PNK_ARRAY: {
+      case ParseNodeKind::CallSiteObj:
+      case ParseNodeKind::Array: {
         unsigned count;
         ParseNode* pn;
 
         if (allowObjects == DontAllowObjects) {
             vp.setMagic(JS_GENERIC_MAGIC);
             return true;
         }
 
         ObjectGroup::NewArrayKind arrayKind = ObjectGroup::NewArrayKind::Normal;
         if (allowObjects == ForCopyOnWriteArray) {
             arrayKind = ObjectGroup::NewArrayKind::CopyOnWrite;
             allowObjects = DontAllowObjects;
         }
 
-        if (getKind() == ParseNodeKind::PNK_CALLSITEOBJ) {
+        if (getKind() == ParseNodeKind::CallSiteObj) {
             count = pn_count - 1;
             pn = pn_head->pn_next;
         } else {
             MOZ_ASSERT(!(pn_xflags & PNX_NONCONST));
             count = pn_count;
             pn = pn_head;
         }
 
@@ -6479,17 +6479,17 @@ ParseNode::getConstantValue(JSContext* c
             return false;
 
         if (!CombineArrayElementTypes(cx, obj, compare, ncompare))
             return false;
 
         vp.setObject(*obj);
         return true;
       }
-      case ParseNodeKind::PNK_OBJECT: {
+      case ParseNodeKind::Object: {
         MOZ_ASSERT(!(pn_xflags & PNX_NONCONST));
 
         if (allowObjects == DontAllowObjects) {
             vp.setMagic(JS_GENERIC_MAGIC);
             return true;
         }
         MOZ_ASSERT(allowObjects == AllowObjects);
 
@@ -6500,21 +6500,21 @@ ParseNode::getConstantValue(JSContext* c
             if (!pn->pn_right->getConstantValue(cx, allowObjects, &value))
                 return false;
             if (value.isMagic(JS_GENERIC_MAGIC)) {
                 vp.setMagic(JS_GENERIC_MAGIC);
                 return true;
             }
 
             ParseNode* pnid = pn->pn_left;
-            if (pnid->isKind(ParseNodeKind::PNK_NUMBER)) {
+            if (pnid->isKind(ParseNodeKind::Number)) {
                 idvalue = NumberValue(pnid->pn_dval);
             } else {
-                MOZ_ASSERT(pnid->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                           pnid->isKind(ParseNodeKind::PNK_STRING));
+                MOZ_ASSERT(pnid->isKind(ParseNodeKind::ObjectPropertyName) ||
+                           pnid->isKind(ParseNodeKind::String));
                 MOZ_ASSERT(pnid->pn_atom != cx->names().proto);
                 idvalue = StringValue(pnid->pn_atom);
             }
 
             RootedId id(cx);
             if (!ValueToId<CanGC>(cx, idvalue, &id))
                 return false;
 
@@ -6538,17 +6538,17 @@ ParseNode::getConstantValue(JSContext* c
     }
     return false;
 }
 
 bool
 BytecodeEmitter::emitSingletonInitialiser(ParseNode* pn)
 {
     NewObjectKind newKind =
-        (pn->getKind() == ParseNodeKind::PNK_OBJECT) ? SingletonObject : TenuredObject;
+        (pn->getKind() == ParseNodeKind::Object) ? SingletonObject : TenuredObject;
 
     RootedValue value(cx);
     if (!pn->getConstantValue(cx, ParseNode::AllowObjects, &value, nullptr, 0, newKind))
         return false;
 
     MOZ_ASSERT_IF(newKind == SingletonObject, value.toObject().isSingleton());
 
     ObjectBox* objbox = parser.newObjectBox(&value.toObject());
@@ -6611,25 +6611,25 @@ BytecodeEmitter::emitCatch(ParseNode* pn
 
     ParseNode* pn2 = pn->pn_left;
     if (!pn2) {
         // Catch parameter was omitted; just discard the exception.
         if (!emit1(JSOP_POP))
             return false;
     } else {
         switch (pn2->getKind()) {
-          case ParseNodeKind::PNK_ARRAY:
-          case ParseNodeKind::PNK_OBJECT:
+          case ParseNodeKind::Array:
+          case ParseNodeKind::Object:
             if (!emitDestructuringOps(pn2, DestructuringDeclaration))
                 return false;
             if (!emit1(JSOP_POP))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_NAME:
+          case ParseNodeKind::Name:
             if (!emitLexicalInitialization(pn2))
                 return false;
             if (!emit1(JSOP_POP))
                 return false;
             break;
 
           default:
             MOZ_ASSERT(0);
@@ -6678,17 +6678,17 @@ BytecodeEmitter::emitTry(ParseNode* pn)
         // [poplexicalenv]              only if any local aliased
         // if there is a finally block:
         //   gosub <finally>
         //   goto <after finally>
         if (!tryCatch.emitCatch())
             return false;
 
         // Emit the lexical scope and catch body.
-        MOZ_ASSERT(catchScope->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+        MOZ_ASSERT(catchScope->isKind(ParseNodeKind::LexicalScope));
         if (!emitTree(catchScope))
             return false;
     }
 
     // Emit the finally handler, if there is one.
     if (finallyNode) {
         if (!tryCatch.emitFinally(Some(finallyNode->pn_pos.begin)))
             return false;
@@ -6725,17 +6725,17 @@ BytecodeEmitter::emitIf(ParseNode* pn)
     /* Emit code for the then part. */
     if (!emitTreeInBranch(pn->pn_kid2))
         return false;
 
     if (elseNode) {
         if (!ifThenElse.emitElse())
             return false;
 
-        if (elseNode->isKind(ParseNodeKind::PNK_IF)) {
+        if (elseNode->isKind(ParseNodeKind::If)) {
             pn = elseNode;
             goto if_again;
         }
 
         /* Emit code for the else part. */
         if (!emitTreeInBranch(elseNode))
             return false;
     }
@@ -6750,50 +6750,50 @@ bool
 BytecodeEmitter::emitHoistedFunctionsInList(ParseNode* list)
 {
     MOZ_ASSERT(list->pn_xflags & PNX_FUNCDEFS);
 
     for (ParseNode* pn = list->pn_head; pn; pn = pn->pn_next) {
         ParseNode* maybeFun = pn;
 
         if (!sc->strict()) {
-            while (maybeFun->isKind(ParseNodeKind::PNK_LABEL))
+            while (maybeFun->isKind(ParseNodeKind::Label))
                 maybeFun = maybeFun->as<LabeledStatement>().statement();
         }
 
-        if (maybeFun->isKind(ParseNodeKind::PNK_FUNCTION) && maybeFun->functionIsHoisted()) {
+        if (maybeFun->isKind(ParseNodeKind::Function) && maybeFun->functionIsHoisted()) {
             if (!emitTree(maybeFun))
                 return false;
         }
     }
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitLexicalScopeBody(ParseNode* body, EmitLineNumberNote emitLineNote)
 {
-    if (body->isKind(ParseNodeKind::PNK_STATEMENTLIST) && body->pn_xflags & PNX_FUNCDEFS) {
+    if (body->isKind(ParseNodeKind::StatementList) && body->pn_xflags & PNX_FUNCDEFS) {
         // This block contains function statements whose definitions are
         // hoisted to the top of the block. Emit these as a separate pass
         // before the rest of the block.
         if (!emitHoistedFunctionsInList(body))
             return false;
     }
 
     // Line notes were updated by emitLexicalScope.
     return emitTree(body, ValueUsage::WantValue, emitLineNote);
 }
 
 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
 // the comment on emitSwitch.
 MOZ_NEVER_INLINE bool
 BytecodeEmitter::emitLexicalScope(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::LexicalScope));
 
     TDZCheckCache tdzCache(this);
 
     ParseNode* body = pn->scopeBody();
     if (pn->isEmptyScope())
         return emitLexicalScopeBody(body);
 
     // Update line number notes before emitting TDZ poison in
@@ -6806,36 +6806,36 @@ BytecodeEmitter::emitLexicalScope(ParseN
     // L2:   let x = 42;
     // L3: }
     //
     // If line number notes were not updated before the TDZ poison, the TDZ
     // poison bytecode sequence of 'uninitialized; initlexical' will have line
     // number L1, and the Debugger will pause there.
     if (!ParseNodeRequiresSpecialLineNumberNotes(body)) {
         ParseNode* pnForPos = body;
-        if (body->isKind(ParseNodeKind::PNK_STATEMENTLIST) && body->pn_head)
+        if (body->isKind(ParseNodeKind::StatementList) && body->pn_head)
             pnForPos = body->pn_head;
         if (!updateLineNumberNotes(pnForPos->pn_pos.begin))
             return false;
     }
 
     EmitterScope emitterScope(this);
     ScopeKind kind;
-    if (body->isKind(ParseNodeKind::PNK_CATCH)) {
-        kind = (!body->pn_left || body->pn_left->isKind(ParseNodeKind::PNK_NAME))
+    if (body->isKind(ParseNodeKind::Catch)) {
+        kind = (!body->pn_left || body->pn_left->isKind(ParseNodeKind::Name))
                ? ScopeKind::SimpleCatch
                : ScopeKind::Catch;
     } else {
         kind = ScopeKind::Lexical;
     }
 
     if (!emitterScope.enterLexical(this, kind, pn->scopeBindings()))
         return false;
 
-    if (body->isKind(ParseNodeKind::PNK_FOR)) {
+    if (body->isKind(ParseNodeKind::For)) {
         // for loops need to emit {FRESHEN,RECREATE}LEXICALENV if there are
         // lexical declarations in the head. Signal this by passing a
         // non-nullptr lexical scope.
         if (!emitFor(body, &emitterScope))
             return false;
     } else {
         if (!emitLexicalScopeBody(body, SUPPRESS_LINENOTE))
             return false;
@@ -7063,45 +7063,45 @@ BytecodeEmitter::emitSpread(bool allowSe
         return false;
 
     return emitPopN(2);                                   // ARR FINAL_INDEX
 }
 
 bool
 BytecodeEmitter::emitInitializeForInOrOfTarget(ParseNode* forHead)
 {
-    MOZ_ASSERT(forHead->isKind(ParseNodeKind::PNK_FORIN) ||
-               forHead->isKind(ParseNodeKind::PNK_FOROF));
+    MOZ_ASSERT(forHead->isKind(ParseNodeKind::ForIn) ||
+               forHead->isKind(ParseNodeKind::ForOf));
     MOZ_ASSERT(forHead->isArity(PN_TERNARY));
 
     MOZ_ASSERT(this->stackDepth >= 1,
                "must have a per-iteration value for initializing");
 
     ParseNode* target = forHead->pn_kid1;
     MOZ_ASSERT(!forHead->pn_kid2);
 
     // If the for-in/of loop didn't have a variable declaration, per-loop
     // initialization is just assigning the iteration value to a target
     // expression.
     if (!parser.isDeclarationList(target))
-        return emitAssignment(target, ParseNodeKind::PNK_ASSIGN, nullptr); // ... ITERVAL
+        return emitAssignment(target, ParseNodeKind::Assign, nullptr); // ... ITERVAL
 
     // Otherwise, per-loop initialization is (possibly) declaration
     // initialization.  If the declaration is a lexical declaration, it must be
     // initialized.  If the declaration is a variable declaration, an
     // assignment to that name (which does *not* necessarily assign to the
     // variable!) must be generated.
 
     if (!updateSourceCoordNotes(target->pn_pos.begin))
         return false;
 
     MOZ_ASSERT(target->isForLoopDeclaration());
     target = parser.singleBindingFromDeclaration(target);
 
-    if (target->isKind(ParseNodeKind::PNK_NAME)) {
+    if (target->isKind(ParseNodeKind::Name)) {
         auto emitSwapScopeAndRhs = [](BytecodeEmitter* bce, const NameLocation&,
                                       bool emittedBindOp)
         {
             if (emittedBindOp) {
                 // Per-iteration initialization in for-in/of loops computes the
                 // iteration value *before* initializing.  Thus the
                 // initializing value may be buried under a bind-specific value
                 // on the stack.  Swap it to the top of the stack.
@@ -7114,48 +7114,48 @@ BytecodeEmitter::emitInitializeForInOrOf
             MOZ_ASSERT(bce->stackDepth >= 1);
             return true;
         };
 
         // The caller handles removing the iteration value from the stack.
         return emitInitializeName(target, emitSwapScopeAndRhs);
     }
 
-    MOZ_ASSERT(!target->isKind(ParseNodeKind::PNK_ASSIGN),
+    MOZ_ASSERT(!target->isKind(ParseNodeKind::Assign),
                "for-in/of loop destructuring declarations can't have initializers");
 
-    MOZ_ASSERT(target->isKind(ParseNodeKind::PNK_ARRAY) ||
-               target->isKind(ParseNodeKind::PNK_OBJECT));
+    MOZ_ASSERT(target->isKind(ParseNodeKind::Array) ||
+               target->isKind(ParseNodeKind::Object));
     return emitDestructuringOps(target, DestructuringDeclaration);
 }
 
 bool
 BytecodeEmitter::emitForOf(ParseNode* forOfLoop, EmitterScope* headLexicalEmitterScope)
 {
-    MOZ_ASSERT(forOfLoop->isKind(ParseNodeKind::PNK_FOR));
+    MOZ_ASSERT(forOfLoop->isKind(ParseNodeKind::For));
     MOZ_ASSERT(forOfLoop->isArity(PN_BINARY));
 
     ParseNode* forOfHead = forOfLoop->pn_left;
-    MOZ_ASSERT(forOfHead->isKind(ParseNodeKind::PNK_FOROF));
+    MOZ_ASSERT(forOfHead->isKind(ParseNodeKind::ForOf));
     MOZ_ASSERT(forOfHead->isArity(PN_TERNARY));
 
     unsigned iflags = forOfLoop->pn_iflags;
     IteratorKind iterKind = (iflags & JSITER_FORAWAITOF)
                             ? IteratorKind::Async
                             : IteratorKind::Sync;
     MOZ_ASSERT_IF(iterKind == IteratorKind::Async, sc->asFunctionBox());
     MOZ_ASSERT_IF(iterKind == IteratorKind::Async, sc->asFunctionBox()->isAsync());
 
     ParseNode* forHeadExpr = forOfHead->pn_kid3;
 
     // Certain builtins (e.g. Array.from) are implemented in self-hosting
     // as for-of loops.
     bool allowSelfHostedIter = false;
     if (emitterMode == BytecodeEmitter::SelfHosting &&
-        forHeadExpr->isKind(ParseNodeKind::PNK_CALL) &&
+        forHeadExpr->isKind(ParseNodeKind::Call) &&
         forHeadExpr->pn_head->name() == cx->names().allowContentIter)
     {
         allowSelfHostedIter = true;
     }
 
     // Evaluate the expression being iterated. The forHeadExpr should use a
     // distinct TDZCheckCache to evaluate since (abstractly) it runs in its own
     // LexicalEnvironment.
@@ -7195,18 +7195,18 @@ BytecodeEmitter::emitForOf(ParseNode* fo
     // environment with an dead zoned one to implement TDZ semantics.
     if (headLexicalEmitterScope) {
         // The environment chain only includes an environment for the for-of
         // loop head *if* a scope binding is captured, thereby requiring
         // recreation each iteration. If a lexical scope exists for the head,
         // it must be the innermost one. If that scope has closed-over
         // bindings inducing an environment, recreate the current environment.
         DebugOnly<ParseNode*> forOfTarget = forOfHead->pn_kid1;
-        MOZ_ASSERT(forOfTarget->isKind(ParseNodeKind::PNK_LET) ||
-                   forOfTarget->isKind(ParseNodeKind::PNK_CONST));
+        MOZ_ASSERT(forOfTarget->isKind(ParseNodeKind::Let) ||
+                   forOfTarget->isKind(ParseNodeKind::Const));
         MOZ_ASSERT(headLexicalEmitterScope == innermostEmitterScope);
         MOZ_ASSERT(headLexicalEmitterScope->scope(this)->kind() == ScopeKind::Lexical);
 
         if (headLexicalEmitterScope->hasEnvironment()) {
             if (!emit1(JSOP_RECREATELEXICALENV))          // ITER UNDEF
                 return false;
         }
 
@@ -7317,32 +7317,32 @@ BytecodeEmitter::emitForOf(ParseNode* fo
         return false;
 
     return emitPopN(2);                                   //
 }
 
 bool
 BytecodeEmitter::emitForIn(ParseNode* forInLoop, EmitterScope* headLexicalEmitterScope)
 {
-    MOZ_ASSERT(forInLoop->isKind(ParseNodeKind::PNK_FOR));
+    MOZ_ASSERT(forInLoop->isKind(ParseNodeKind::For));
     MOZ_ASSERT(forInLoop->isArity(PN_BINARY));
     MOZ_ASSERT(forInLoop->isOp(JSOP_ITER));
 
     ParseNode* forInHead = forInLoop->pn_left;
-    MOZ_ASSERT(forInHead->isKind(ParseNodeKind::PNK_FORIN));
+    MOZ_ASSERT(forInHead->isKind(ParseNodeKind::ForIn));
     MOZ_ASSERT(forInHead->isArity(PN_TERNARY));
 
     // Annex B: Evaluate the var-initializer expression if present.
     // |for (var i = initializer in expr) { ... }|
     ParseNode* forInTarget = forInHead->pn_kid1;
     if (parser.isDeclarationList(forInTarget)) {
         ParseNode* decl = parser.singleBindingFromDeclaration(forInTarget);
-        if (decl->isKind(ParseNodeKind::PNK_NAME)) {
+        if (decl->isKind(ParseNodeKind::Name)) {
             if (ParseNode* initializer = decl->expr()) {
-                MOZ_ASSERT(forInTarget->isKind(ParseNodeKind::PNK_VAR),
+                MOZ_ASSERT(forInTarget->isKind(ParseNodeKind::Var),
                            "for-in initializers are only permitted for |var| declarations");
 
                 if (!updateSourceCoordNotes(decl->pn_pos.begin))
                     return false;
 
                 auto emitRhs = [decl, initializer](BytecodeEmitter* bce, const NameLocation&, bool) {
                     return bce->emitInitializer(initializer, decl);
                 };
@@ -7392,18 +7392,18 @@ BytecodeEmitter::emitForIn(ParseNode* fo
     // If the loop had an escaping lexical declaration, replace the current
     // environment with an dead zoned one to implement TDZ semantics.
     if (headLexicalEmitterScope) {
         // The environment chain only includes an environment for the for-in
         // loop head *if* a scope binding is captured, thereby requiring
         // recreation each iteration. If a lexical scope exists for the head,
         // it must be the innermost one. If that scope has closed-over
         // bindings inducing an environment, recreate the current environment.
-        MOZ_ASSERT(forInTarget->isKind(ParseNodeKind::PNK_LET) ||
-                   forInTarget->isKind(ParseNodeKind::PNK_CONST));
+        MOZ_ASSERT(forInTarget->isKind(ParseNodeKind::Let) ||
+                   forInTarget->isKind(ParseNodeKind::Const));
         MOZ_ASSERT(headLexicalEmitterScope == innermostEmitterScope);
         MOZ_ASSERT(headLexicalEmitterScope->scope(this)->kind() == ScopeKind::Lexical);
 
         if (headLexicalEmitterScope->hasEnvironment()) {
             if (!emit1(JSOP_RECREATELEXICALENV))          // ITER ITERVAL
                 return false;
         }
 
@@ -7476,17 +7476,17 @@ bool
 BytecodeEmitter::emitCStyleFor(ParseNode* pn, EmitterScope* headLexicalEmitterScope)
 {
     LoopControl loopInfo(this, StatementKind::ForLoop);
 
     ParseNode* forHead = pn->pn_left;
     ParseNode* forBody = pn->pn_right;
 
     // If the head of this for-loop declared any lexical variables, the parser
-    // wrapped this ParseNodeKind::PNK_FOR node in a ParseNodeKind::PNK_LEXICALSCOPE
+    // wrapped this ParseNodeKind::For node in a ParseNodeKind::LexicalScope
     // representing the implicit scope of those variables. By the time we get here,
     // we have already entered that scope. So far, so good.
     //
     // ### Scope freshening
     //
     // Each iteration of a `for (let V...)` loop creates a fresh loop variable
     // binding for V, even if the loop is a C-style `for(;;)` loop:
     //
@@ -7522,17 +7522,17 @@ BytecodeEmitter::emitCStyleFor(ParseNode
                 return false;
         }
 
         // ES 13.7.4.8 step 2. The initial freshening.
         //
         // If an initializer let-declaration may be captured during loop iteration,
         // the current scope has an environment.  If so, freshen the current
         // environment to expose distinct bindings for each loop iteration.
-        forLoopRequiresFreshening = init->isKind(ParseNodeKind::PNK_LET) && headLexicalEmitterScope;
+        forLoopRequiresFreshening = init->isKind(ParseNodeKind::Let) && headLexicalEmitterScope;
         if (forLoopRequiresFreshening) {
             // The environment chain only includes an environment for the for(;;)
             // loop head's let-declaration *if* a scope binding is captured, thus
             // requiring a fresh environment each iteration. If a lexical scope
             // exists for the head, it must be the innermost one. If that scope
             // has closed-over bindings inducing an environment, recreate the
             // current environment.
             MOZ_ASSERT(headLexicalEmitterScope == innermostEmitterScope);
@@ -7656,28 +7656,28 @@ BytecodeEmitter::emitCStyleFor(ParseNode
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitFor(ParseNode* pn, EmitterScope* headLexicalEmitterScope)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_FOR));
-
-    if (pn->pn_left->isKind(ParseNodeKind::PNK_FORHEAD))
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::For));
+
+    if (pn->pn_left->isKind(ParseNodeKind::ForHead))
         return emitCStyleFor(pn, headLexicalEmitterScope);
 
     if (!updateLineNumberNotes(pn->pn_pos.begin))
         return false;
 
-    if (pn->pn_left->isKind(ParseNodeKind::PNK_FORIN))
+    if (pn->pn_left->isKind(ParseNodeKind::ForIn))
         return emitForIn(pn, headLexicalEmitterScope);
 
-    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_FOROF));
+    MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::ForOf));
     return emitForOf(pn, headLexicalEmitterScope);
 }
 
 MOZ_NEVER_INLINE bool
 BytecodeEmitter::emitFunction(ParseNode* pn, bool needsProto)
 {
     FunctionBox* funbox = pn->pn_funbox;
     RootedFunction fun(cx, funbox->function());
@@ -8141,38 +8141,38 @@ BytecodeEmitter::emitContinue(PropertyNa
     }
     return emitGoto(target, &target->continues, SRC_CONTINUE);
 }
 
 bool
 BytecodeEmitter::emitGetFunctionThis(ParseNode* pn)
 {
     MOZ_ASSERT(sc->thisBinding() == ThisBinding::Function);
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Name));
     MOZ_ASSERT(pn->name() == cx->names().dotThis);
 
     if (!emitTree(pn))
         return false;
     if (sc->needsThisTDZChecks() && !emit1(JSOP_CHECKTHIS))
         return false;
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitGetThisForSuperBase(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_SUPERBASE));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::SuperBase));
     return emitGetFunctionThis(pn->pn_kid);
 }
 
 bool
 BytecodeEmitter::emitThisLiteral(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_THIS));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::This));
 
     if (ParseNode* thisName = pn->pn_kid)
         return emitGetFunctionThis(thisName);
 
     if (sc->thisBinding() == ThisBinding::Module)
         return emit1(JSOP_UNDEFINED);
 
     MOZ_ASSERT(sc->thisBinding() == ThisBinding::Global);
@@ -8306,17 +8306,17 @@ BytecodeEmitter::emitInitialYield(ParseN
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitYield(ParseNode* pn)
 {
     MOZ_ASSERT(sc->isFunctionBox());
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_YIELD));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Yield));
 
     bool needsIteratorResult = sc->asFunctionBox()->needsIteratorResult();
     if (needsIteratorResult) {
         if (!emitPrepareIteratorResult())
             return false;
     }
     if (pn->pn_kid) {
         if (!emitTree(pn->pn_kid))
@@ -8356,17 +8356,17 @@ BytecodeEmitter::emitAwait()
         return false;
     return true;
 }
 
 bool
 BytecodeEmitter::emitAwait(ParseNode* pn)
 {
     MOZ_ASSERT(sc->isFunctionBox());
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_AWAIT));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Await));
 
     if (!emitTree(pn->pn_kid))
         return false;
     return emitAwait();
 }
 
 bool
 BytecodeEmitter::emitYieldStar(ParseNode* iter)
@@ -8660,17 +8660,17 @@ BytecodeEmitter::emitStatementList(Parse
             return false;
     }
     return true;
 }
 
 bool
 BytecodeEmitter::emitStatement(ParseNode* pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_SEMI));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Semi));
 
     ParseNode* pn2 = pn->pn_kid;
     if (!pn2)
         return true;
 
     if (!updateSourceCoordNotes(pn->pn_pos.begin))
         return false;
 
@@ -8706,17 +8706,17 @@ BytecodeEmitter::emitStatement(ParseNode
         {
             useful = true;
         }
     }
 
     if (useful) {
         JSOp op = wantval ? JSOP_SETRVAL : JSOP_POP;
         ValueUsage valueUsage = wantval ? ValueUsage::WantValue : ValueUsage::IgnoreValue;
-        MOZ_ASSERT_IF(pn2->isKind(ParseNodeKind::PNK_ASSIGN), pn2->isOp(JSOP_NOP));
+        MOZ_ASSERT_IF(pn2->isKind(ParseNodeKind::Assign), pn2->isOp(JSOP_NOP));
         if (!emitTree(pn2, valueUsage))
             return false;
         if (!emit1(op))
             return false;
     } else if (pn->isDirectivePrologueMember()) {
         // Don't complain about directive prologue members; just don't emit
         // their code.
     } else {
@@ -8748,33 +8748,33 @@ BytecodeEmitter::emitStatement(ParseNode
     }
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitDeleteName(ParseNode* node)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETENAME));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteName));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode* nameExpr = node->pn_kid;
-    MOZ_ASSERT(nameExpr->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(nameExpr->isKind(ParseNodeKind::Name));
 
     return emitAtomOp(nameExpr, JSOP_DELNAME);
 }
 
 bool
 BytecodeEmitter::emitDeleteProperty(ParseNode* node)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEPROP));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteProp));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode* propExpr = node->pn_kid;
-    MOZ_ASSERT(propExpr->isKind(ParseNodeKind::PNK_DOT));
+    MOZ_ASSERT(propExpr->isKind(ParseNodeKind::Dot));
 
     if (propExpr->as<PropertyAccess>().isSuper()) {
         // Still have to calculate the base, even though we are are going
         // to throw unconditionally, as calculating the base could also
         // throw.
         if (!emit1(JSOP_SUPERBASE))
             return false;
 
@@ -8783,21 +8783,21 @@ BytecodeEmitter::emitDeleteProperty(Pars
 
     JSOp delOp = sc->strict() ? JSOP_STRICTDELPROP : JSOP_DELPROP;
     return emitPropOp(propExpr, delOp);
 }
 
 bool
 BytecodeEmitter::emitDeleteElement(ParseNode* node)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEELEM));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteElem));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode* elemExpr = node->pn_kid;
-    MOZ_ASSERT(elemExpr->isKind(ParseNodeKind::PNK_ELEM));
+    MOZ_ASSERT(elemExpr->isKind(ParseNodeKind::Elem));
 
     if (elemExpr->as<PropertyByValue>().isSuper()) {
         // Still have to calculate everything, even though we're gonna throw
         // since it may have side effects
         if (!emitTree(elemExpr->pn_right))
             return false;
 
         if (!emit1(JSOP_SUPERBASE))
@@ -8812,17 +8812,17 @@ BytecodeEmitter::emitDeleteElement(Parse
 
     JSOp delOp = sc->strict() ? JSOP_STRICTDELELEM : JSOP_DELELEM;
     return emitElemOp(elemExpr, delOp);
 }
 
 bool
 BytecodeEmitter::emitDeleteExpression(ParseNode* node)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEEXPR));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteExpr));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode* expression = node->pn_kid;
 
     // If useless, just emit JSOP_TRUE; otherwise convert |delete <expr>| to
     // effectively |<expr>, true|.
     bool useful = false;
     if (!checkSideEffects(expression, &useful))
@@ -8876,17 +8876,17 @@ BytecodeEmitter::emitSelfHostedCallFunct
         reportError(pn, JSMSG_NOT_CONSTRUCTOR, errorName);
         return false;
     }
 
     bool constructing = pn2->name() == cx->names().constructContentFunction;
     ParseNode* funNode = pn2->pn_next;
     if (constructing) {
         callOp = JSOP_NEW;
-    } else if (funNode->getKind() == ParseNodeKind::PNK_NAME &&
+    } else if (funNode->getKind() == ParseNodeKind::Name &&
                funNode->name() == cx->names().std_Function_apply) {
         callOp = JSOP_FUNAPPLY;
     }
 
     if (!emitTree(funNode))
         return false;
 
 #ifdef DEBUG
@@ -8943,17 +8943,17 @@ BytecodeEmitter::emitSelfHostedResumeGen
     if (!emitTree(genNode))
         return false;
 
     ParseNode* valNode = genNode->pn_next;
     if (!emitTree(valNode))
         return false;
 
     ParseNode* kindNode = valNode->pn_next;
-    MOZ_ASSERT(kindNode->isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(kindNode->isKind(ParseNodeKind::String));
     uint16_t operand = GeneratorObject::getResumeKind(cx, kindNode->pn_atom);
     MOZ_ASSERT(!kindNode->pn_next);
 
     if (!emitCall(JSOP_RESUME, operand))
         return false;
 
     return true;
 }
@@ -9059,20 +9059,20 @@ BytecodeEmitter::isRestParameter(ParseNo
     if (!sc->isFunctionBox())
         return false;
 
     FunctionBox* funbox = sc->asFunctionBox();
     RootedFunction fun(cx, funbox->function());
     if (!funbox->hasRest())
         return false;
 
-    if (!pn->isKind(ParseNodeKind::PNK_NAME)) {
-        if (emitterMode == BytecodeEmitter::SelfHosting && pn->isKind(ParseNodeKind::PNK_CALL)) {
+    if (!pn->isKind(ParseNodeKind::Name)) {
+        if (emitterMode == BytecodeEmitter::SelfHosting && pn->isKind(ParseNodeKind::Call)) {
             ParseNode* pn2 = pn->pn_head;
-            if (pn2->getKind() == ParseNodeKind::PNK_NAME &&
+            if (pn2->getKind() == ParseNodeKind::Name &&
                 pn2->name() == cx->names().allowContentIter)
             {
                 return isRestParameter(pn2->pn_next);
             }
         }
         return false;
     }
 
@@ -9090,47 +9090,47 @@ BytecodeEmitter::isRestParameter(ParseNo
 
     return false;
 }
 
 bool
 BytecodeEmitter::emitCallee(ParseNode* callee, ParseNode* call, bool spread, bool* callop)
 {
     switch (callee->getKind()) {
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Name:
         if (!emitGetName(callee, *callop))
             return false;
         break;
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         MOZ_ASSERT(emitterMode != BytecodeEmitter::SelfHosting);
         if (callee->as<PropertyAccess>().isSuper()) {
             if (!emitSuperPropOp(callee, JSOP_GETPROP_SUPER, /* isCall = */ *callop))
                 return false;
         } else {
             if (!emitPropOp(callee, *callop ? JSOP_CALLPROP : JSOP_GETPROP))
                 return false;
         }
 
         break;
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
         MOZ_ASSERT(emitterMode != BytecodeEmitter::SelfHosting);
         if (callee->as<PropertyByValue>().isSuper()) {
             if (!emitSuperElemOp(callee, JSOP_GETELEM_SUPER, /* isCall = */ *callop))
                 return false;
         } else {
             if (!emitElemOp(callee, *callop ? JSOP_CALLELEM : JSOP_GETELEM))
                 return false;
             if (*callop) {
                 if (!emit1(JSOP_SWAP))
                     return false;
             }
         }
 
         break;
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         /*
          * Top level lambdas which are immediately invoked should be
          * treated as only running once. Every time they execute we will
          * create new types and scripts for their contents, to increase
          * the quality of type information within them and enable more
          * backend optimizations. Note that this does not depend on the
          * lambda being invoked at most once (it may be named or be
          * accessed via foo.caller indirection), as multiple executions
@@ -9143,18 +9143,18 @@ BytecodeEmitter::emitCallee(ParseNode* c
                 return false;
             emittingRunOnceLambda = false;
         } else {
             if (!emitTree(callee))
                 return false;
         }
         *callop = false;
         break;
-      case ParseNodeKind::PNK_SUPERBASE:
-        MOZ_ASSERT(call->isKind(ParseNodeKind::PNK_SUPERCALL));
+      case ParseNodeKind::SuperBase:
+        MOZ_ASSERT(call->isKind(ParseNodeKind::SuperCall));
         MOZ_ASSERT(parser.isSuperBase(callee));
         if (!emit1(JSOP_SUPERFUN))
             return false;
         break;
       default:
         if (!emitTree(callee))
             return false;
         *callop = false;             /* trigger JSOP_UNDEFINED after */
@@ -9197,17 +9197,17 @@ BytecodeEmitter::emitPipeline(ParseNode*
 
     return true;
 }
 
 bool
 BytecodeEmitter::emitCallOrNew(ParseNode* pn, ValueUsage valueUsage /* = ValueUsage::WantValue */)
 {
     bool callop =
-        pn->isKind(ParseNodeKind::PNK_CALL) || pn->isKind(ParseNodeKind::PNK_TAGGED_TEMPLATE);
+        pn->isKind(ParseNodeKind::Call) || pn->isKind(ParseNodeKind::TaggedTemplate);
     /*
      * Emit callable invocation or operator new (constructor call) code.
      * First, emit code for the left operand to evaluate the callable or
      * constructable object expression.
      *
      * For operator new, we emit JSOP_GETPROP instead of JSOP_CALLPROP, etc.
      * This is necessary to interpose the lambda-initialized method read
      * barrier -- see the code in jsinterp.cpp for JSOP_LAMBDA followed by
@@ -9223,17 +9223,17 @@ BytecodeEmitter::emitCallOrNew(ParseNode
     if (argc >= ARGC_LIMIT) {
         parser.reportError(callop ? JSMSG_TOO_MANY_FUN_ARGS : JSMSG_TOO_MANY_CON_ARGS);
         return false;
     }
 
     ParseNode* pn2 = pn->pn_head;
     bool spread = JOF_OPTYPE(pn->getOp()) == JOF_BYTE;
 
-    if (pn2->isKind(ParseNodeKind::PNK_NAME) && emitterMode == BytecodeEmitter::SelfHosting && !spread) {
+    if (pn2->isKind(ParseNodeKind::Name) && emitterMode == BytecodeEmitter::SelfHosting && !spread) {
         // Calls to "forceInterpreter", "callFunction",
         // "callContentFunction", or "resumeGenerator" in self-hosted
         // code generate inline bytecode.
         if (pn2->name() == cx->names().callFunction ||
             pn2->name() == cx->names().callContentFunction ||
             pn2->name() == cx->names().constructContentFunction)
         {
             return emitSelfHostedCallFunction(pn);
@@ -9278,17 +9278,17 @@ BytecodeEmitter::emitCallOrNew(ParseNode
      */
     if (!spread) {
         for (ParseNode* pn3 = pn2->pn_next; pn3; pn3 = pn3->pn_next) {
             if (!emitTree(pn3))
                 return false;
         }
 
         if (isNewOp) {
-            if (pn->isKind(ParseNodeKind::PNK_SUPERCALL)) {
+            if (pn->isKind(ParseNodeKind::SuperCall)) {
                 if (!emit1(JSOP_NEWTARGET))
                     return false;
             } else {
                 // Repush the callee as new.target
                 if (!emitDupAt(argc + 1))
                     return false;
             }
         }
@@ -9330,17 +9330,17 @@ BytecodeEmitter::emitCallOrNew(ParseNode
             return false;
 
         if (emitOptCode) {
             if (!ifNotOptimizable.emitEnd())
                 return false;
         }
 
         if (isNewOp) {
-            if (pn->isKind(ParseNodeKind::PNK_SUPERCALL)) {
+            if (pn->isKind(ParseNodeKind::SuperCall)) {
                 if (!emit1(JSOP_NEWTARGET))
                     return false;
             } else {
                 if (!emitDupAt(2))
                     return false;
             }
         }
     }
@@ -9401,26 +9401,26 @@ static const JSOp ParseNodeKindToJSOp[] 
     JSOP_DIV,
     JSOP_MOD,
     JSOP_POW
 };
 
 static inline JSOp
 BinaryOpParseNodeKindToJSOp(ParseNodeKind pnk)
 {
-    MOZ_ASSERT(pnk >= ParseNodeKind::PNK_BINOP_FIRST);
-    MOZ_ASSERT(pnk <= ParseNodeKind::PNK_BINOP_LAST);
-    return ParseNodeKindToJSOp[size_t(pnk) - size_t(ParseNodeKind::PNK_BINOP_FIRST)];
+    MOZ_ASSERT(pnk >= ParseNodeKind::BinOpFirst);
+    MOZ_ASSERT(pnk <= ParseNodeKind::BinOpLast);
+    return ParseNodeKindToJSOp[size_t(pnk) - size_t(ParseNodeKind::BinOpFirst)];
 }
 
 bool
 BytecodeEmitter::emitRightAssociative(ParseNode* pn)
 {
     // ** is the only right-associative operator.
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_POW));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Pow));
     MOZ_ASSERT(pn->isArity(PN_LIST));
 
     // Right-associative operator chain.
     for (ParseNode* subexpr = pn->pn_head; subexpr; subexpr = subexpr->pn_next) {
         if (!emitTree(subexpr))
             return false;
     }
     for (uint32_t i = 0; i < pn->pn_count - 1; i++) {
@@ -9448,17 +9448,17 @@ BytecodeEmitter::emitLeftAssociative(Par
     } while ((nextExpr = nextExpr->pn_next));
     return true;
 }
 
 bool
 BytecodeEmitter::emitLogical(ParseNode* pn)
 {
     MOZ_ASSERT(pn->isArity(PN_LIST));
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_OR) || pn->isKind(ParseNodeKind::PNK_AND));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::Or) || pn->isKind(ParseNodeKind::And));
 
     /*
      * JSOP_OR converts the operand on the stack to boolean, leaves the original
      * value on the stack and jumps if true; otherwise it falls into the next
      * bytecode, which pops the left operand and then evaluates the right operand.
      * The jump goes around the right operand evaluation.
      *
      * JSOP_AND converts the operand on the stack to boolean and jumps if false;
@@ -9466,17 +9466,17 @@ BytecodeEmitter::emitLogical(ParseNode* 
      */
 
     TDZCheckCache tdzCache(this);
 
     /* Left-associative operator chain: avoid too much recursion. */
     ParseNode* pn2 = pn->pn_head;
     if (!emitTree(pn2))
         return false;
-    JSOp op = pn->isKind(ParseNodeKind::PNK_OR) ? JSOP_OR : JSOP_AND;
+    JSOp op = pn->isKind(ParseNodeKind::Or) ? JSOP_OR : JSOP_AND;
     JumpList jump;
     if (!emitJump(op, &jump))
         return false;
     if (!emit1(JSOP_POP))
         return false;
 
     /* Emit nodes between the head and the tail. */
     while ((pn2 = pn2->pn_next)->pn_next) {
@@ -9513,21 +9513,21 @@ BytecodeEmitter::emitSequenceExpr(ParseN
 }
 
 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
 // the comment on emitSwitch.
 MOZ_NEVER_INLINE bool
 BytecodeEmitter::emitIncOrDec(ParseNode* pn)
 {
     switch (pn->pn_kid->getKind()) {
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         return emitPropIncDec(pn);
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
         return emitElemIncDec(pn);
-      case ParseNodeKind::PNK_CALL:
+      case ParseNodeKind::Call:
         return emitCallIncDec(pn);
       default:
         return emitNameIncDec(pn);
     }
 }
 
 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
 // the comment on emitSwitch.
@@ -9594,27 +9594,27 @@ bool
 BytecodeEmitter::emitPropertyList(ParseNode* pn, MutableHandlePlainObject objp, PropListType type)
 {
     for (ParseNode* propdef = pn->pn_head; propdef; propdef = propdef->pn_next) {
         if (!updateSourceCoordNotes(propdef->pn_pos.begin))
             return false;
 
         // Handle __proto__: v specially because *only* this form, and no other
         // involving "__proto__", performs [[Prototype]] mutation.
-        if (propdef->isKind(ParseNodeKind::PNK_MUTATEPROTO)) {
+        if (propdef->isKind(ParseNodeKind::MutateProto)) {
             MOZ_ASSERT(type == ObjectLiteral);
             if (!emitTree(propdef->pn_kid))
                 return false;
             objp.set(nullptr);
             if (!emit1(JSOP_MUTATEPROTO))
                 return false;
             continue;
         }
 
-        if (propdef->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (propdef->isKind(ParseNodeKind::Spread)) {
             MOZ_ASSERT(type == ObjectLiteral);
 
             if (!emit1(JSOP_DUP))
                 return false;
 
             if (!emitTree(propdef->pn_kid))
                 return false;
 
@@ -9632,22 +9632,22 @@ BytecodeEmitter::emitPropertyList(ParseN
                 return false;
             if (!emit1(JSOP_POP))
                 return false;
         }
 
         /* Emit an index for t[2] for later consumption by JSOP_INITELEM. */
         ParseNode* key = propdef->pn_left;
         bool isIndex = false;
-        if (key->isKind(ParseNodeKind::PNK_NUMBER)) {
+        if (key->isKind(ParseNodeKind::Number)) {
             if (!emitNumberOp(key->pn_dval))
                 return false;
             isIndex = true;
-        } else if (key->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                   key->isKind(ParseNodeKind::PNK_STRING))
+        } else if (key->isKind(ParseNodeKind::ObjectPropertyName) ||
+                   key->isKind(ParseNodeKind::String))
         {
             // EmitClass took care of constructor already.
             if (type == ClassBody && key->pn_atom == cx->names().constructor &&
                 !propdef->as<ClassMethod>().isStatic())
             {
                 continue;
             }
         } else {
@@ -9667,17 +9667,17 @@ BytecodeEmitter::emitPropertyList(ParseN
 
         FunctionPrefixKind prefixKind = op == JSOP_INITPROP_GETTER ? FunctionPrefixKind::Get
                                         : op == JSOP_INITPROP_SETTER ? FunctionPrefixKind::Set
                                         : FunctionPrefixKind::None;
 
         if (op == JSOP_INITPROP_GETTER || op == JSOP_INITPROP_SETTER)
             objp.set(nullptr);
 
-        if (propdef->pn_right->isKind(ParseNodeKind::PNK_FUNCTION) &&
+        if (propdef->pn_right->isKind(ParseNodeKind::Function) &&
             propdef->pn_right->pn_funbox->needsHomeObject())
         {
             MOZ_ASSERT(propdef->pn_right->pn_funbox->function()->allowSuperProperty());
             bool isAsync = propdef->pn_right->pn_funbox->isAsync();
             if (isAsync) {
                 if (!emit1(JSOP_SWAP))
                     return false;
             }
@@ -9714,18 +9714,18 @@ BytecodeEmitter::emitPropertyList(ParseN
                 if (!emitDupAt(1))
                     return false;
                 if (!emit2(JSOP_SETFUNNAME, uint8_t(prefixKind)))
                     return false;
             }
             if (!emit1(op))
                 return false;
         } else {
-            MOZ_ASSERT(key->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                       key->isKind(ParseNodeKind::PNK_STRING));
+            MOZ_ASSERT(key->isKind(ParseNodeKind::ObjectPropertyName) ||
+                       key->isKind(ParseNodeKind::String));
 
             uint32_t index;
             if (!makeAtomIndex(key->pn_atom, &index))
                 return false;
 
             if (objp) {
                 MOZ_ASSERT(type == ObjectLiteral);
                 MOZ_ASSERT(!IsHiddenInitOp(op));
@@ -9870,17 +9870,17 @@ BytecodeEmitter::emitArray(ParseNode* pn
      * it to the array, without invoking latent setters.  We use the
      * JSOP_NEWINIT and JSOP_INITELEM_ARRAY bytecodes to ignore setters and
      * to avoid dup'ing and popping the array as each element is added, as
      * JSOP_SETELEM/JSOP_SETPROP would do.
      */
 
     uint32_t nspread = 0;
     for (ParseNode* elt = pn; elt; elt = elt->pn_next) {
-        if (elt->isKind(ParseNodeKind::PNK_SPREAD))
+        if (elt->isKind(ParseNodeKind::Spread))
             nspread++;
     }
 
     // Array literal's length is limited to NELEMENTS_LIMIT in parser.
     static_assert(NativeObject::MAX_DENSE_ELEMENTS_COUNT <= INT32_MAX,
                   "array literals' maximum length must not exceed limits "
                   "required by BaselineCompiler::emit_JSOP_NEWARRAY, "
                   "BaselineCompiler::emit_JSOP_INITELEM_ARRAY, "
@@ -9894,46 +9894,46 @@ BytecodeEmitter::emitArray(ParseNode* pn
     // minimum possible final size.
     if (!emitUint32Operand(JSOP_NEWARRAY, count - nspread))         // ARRAY
         return false;
 
     ParseNode* pn2 = pn;
     uint32_t index;
     bool afterSpread = false;
     for (index = 0; pn2; index++, pn2 = pn2->pn_next) {
-        if (!afterSpread && pn2->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (!afterSpread && pn2->isKind(ParseNodeKind::Spread)) {
             afterSpread = true;
             if (!emitNumberOp(index))                               // ARRAY INDEX
                 return false;
         }
         if (!updateSourceCoordNotes(pn2->pn_pos.begin))
             return false;
 
         bool allowSelfHostedIter = false;
-        if (pn2->isKind(ParseNodeKind::PNK_ELISION)) {
+        if (pn2->isKind(ParseNodeKind::Elision)) {
             if (!emit1(JSOP_HOLE))
                 return false;
         } else {
             ParseNode* expr;
-            if (pn2->isKind(ParseNodeKind::PNK_SPREAD)) {
+            if (pn2->isKind(ParseNodeKind::Spread)) {
                 expr = pn2->pn_kid;
 
                 if (emitterMode == BytecodeEmitter::SelfHosting &&
-                    expr->isKind(ParseNodeKind::PNK_CALL) &&
+                    expr->isKind(ParseNodeKind::Call) &&
                     expr->pn_head->name() == cx->names().allowContentIter)
                 {
                     allowSelfHostedIter = true;
                 }
             } else {
                 expr = pn2;
             }
             if (!emitTree(expr))                                         // ARRAY INDEX? VALUE
                 return false;
         }
-        if (pn2->isKind(ParseNodeKind::PNK_SPREAD)) {
+        if (pn2->isKind(ParseNodeKind::Spread)) {
             if (!emitIterator())                                         // ARRAY INDEX ITER
                 return false;
             if (!emit2(JSOP_PICK, 2))                                    // INDEX ITER ARRAY
                 return false;
             if (!emit2(JSOP_PICK, 2))                                    // ITER ARRAY INDEX
                 return false;
             if (!emitSpread(allowSelfHostedIter))                        // ARRAY INDEX
                 return false;
@@ -9952,22 +9952,22 @@ BytecodeEmitter::emitArray(ParseNode* pn
     }
     return true;
 }
 
 static inline JSOp
 UnaryOpParseNodeKindToJSOp(ParseNodeKind pnk)
 {
     switch (pnk) {
-      case ParseNodeKind::PNK_THROW: return JSOP_THROW;
-      case ParseNodeKind::PNK_VOID: return JSOP_VOID;
-      case ParseNodeKind::PNK_NOT: return JSOP_NOT;
-      case ParseNodeKind::PNK_BITNOT: return JSOP_BITNOT;
-      case ParseNodeKind::PNK_POS: return JSOP_POS;
-      case ParseNodeKind::PNK_NEG: return JSOP_NEG;
+      case ParseNodeKind::Throw: return JSOP_THROW;
+      case ParseNodeKind::Void: return JSOP_VOID;
+      case ParseNodeKind::Not: return JSOP_NOT;
+      case ParseNodeKind::BitNot: return JSOP_BITNOT;
+      case ParseNodeKind::Pos: return JSOP_POS;
+      case ParseNodeKind::Neg: return JSOP_NEG;
       default: MOZ_CRASH("unexpected unary op");
     }
 }
 
 bool
 BytecodeEmitter::emitUnary(ParseNode* pn)
 {
     if (!updateSourceCoordNotes(pn->pn_pos.begin))
@@ -9989,17 +9989,17 @@ BytecodeEmitter::emitTypeof(ParseNode* n
         return false;
 
     return emit1(op);
 }
 
 bool
 BytecodeEmitter::emitFunctionFormalParametersAndBody(ParseNode *pn)
 {
-    MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_PARAMSBODY));
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::ParamsBody));
 
     ParseNode* funBody = pn->last();
     FunctionBox* funbox = sc->asFunctionBox();
 
     TDZCheckCache tdzCache(this);
 
     if (funbox->hasParameterExprs) {
         EmitterScope funEmitterScope(this);
@@ -10102,31 +10102,31 @@ BytecodeEmitter::emitFunctionFormalParam
 
     bool hasParameterExprs = funbox->hasParameterExprs;
     bool hasRest = funbox->hasRest();
 
     uint16_t argSlot = 0;
     for (ParseNode* arg = pn->pn_head; arg != funBody; arg = arg->pn_next, argSlot++) {
         ParseNode* bindingElement = arg;
         ParseNode* initializer = nullptr;
-        if (arg->isKind(ParseNodeKind::PNK_ASSIGN)) {
+        if (arg->isKind(ParseNodeKind::Assign)) {
             bindingElement = arg->pn_left;
             initializer = arg->pn_right;
         }
 
         // Left-hand sides are either simple names or destructuring patterns.
-        MOZ_ASSERT(bindingElement->isKind(ParseNodeKind::PNK_NAME) ||
-                   bindingElement->isKind(ParseNodeKind::PNK_ARRAY) ||
-                   bindingElement->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(bindingElement->isKind(ParseNodeKind::Name) ||
+                   bindingElement->isKind(ParseNodeKind::Array) ||
+                   bindingElement->isKind(ParseNodeKind::Object));
 
         // The rest parameter doesn't have an initializer.
         bool isRest = hasRest && arg->pn_next == funBody;
         MOZ_ASSERT_IF(isRest, !initializer);
 
-        bool isDestructuring = !bindingElement->isKind(ParseNodeKind::PNK_NAME);
+        bool isDestructuring = !bindingElement->isKind(ParseNodeKind::Name);
 
         // ES 14.1.19 says if BindingElement contains an expression in the
         // production FormalParameter : BindingElement, it is evaluated in a
         // new var environment. This is needed to prevent vars from escaping
         // direct eval in parameter expressions.
         Maybe<EmitterScope> paramExprVarScope;
         if (funbox->hasDirectEvalInParameterExpr && (isDestructuring || initializer)) {
             paramExprVarScope.emplace(this);
@@ -10350,18 +10350,18 @@ BytecodeEmitter::emitClass(ParseNode* pn
     ParseNode* heritageExpression = classNode.heritage();
 
     ParseNode* classMethods = classNode.methodList();
     ParseNode* constructor = nullptr;
     for (ParseNode* mn = classMethods->pn_head; mn; mn = mn->pn_next) {
         ClassMethod& method = mn->as<ClassMethod>();
         ParseNode& methodName = method.name();
         if (!method.isStatic() &&
-            (methodName.isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-             methodName.isKind(ParseNodeKind::PNK_STRING)) &&
+            (methodName.isKind(ParseNodeKind::ObjectPropertyName) ||
+             methodName.isKind(ParseNodeKind::String)) &&
             methodName.pn_atom == cx->names().constructor)
         {
             constructor = &method.method();
             break;
         }
     }
 
     bool savedStrictness = sc->setLocalStrictMode(true);
@@ -10582,385 +10582,385 @@ BytecodeEmitter::emitTree(ParseNode* pn,
        However, a couple trees require special treatment; see the
        relevant emitter functions for details. */
     if (emitLineNote == EMIT_LINENOTE && !ParseNodeRequiresSpecialLineNumberNotes(pn)) {
         if (!updateLineNumberNotes(pn->pn_pos.begin))
             return false;
     }
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         if (!emitFunction(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_PARAMSBODY:
+      case ParseNodeKind::ParamsBody:
         if (!emitFunctionFormalParametersAndBody(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_IF:
+      case ParseNodeKind::If:
         if (!emitIf(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_SWITCH:
+      case ParseNodeKind::Switch:
         if (!emitSwitch(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_WHILE:
+      case ParseNodeKind::While:
         if (!emitWhile(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DOWHILE:
+      case ParseNodeKind::DoWhile:
         if (!emitDo(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_FOR:
+      case ParseNodeKind::For:
         if (!emitFor(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_BREAK:
+      case ParseNodeKind::Break:
         if (!emitBreak(pn->as<BreakStatement>().label()))
             return false;
         break;
 
-      case ParseNodeKind::PNK_CONTINUE:
+      case ParseNodeKind::Continue:
         if (!emitContinue(pn->as<ContinueStatement>().label()))
             return false;
         break;
 
-      case ParseNodeKind::PNK_WITH:
+      case ParseNodeKind::With:
         if (!emitWith(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TRY:
+      case ParseNodeKind::Try:
         if (!emitTry(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_CATCH:
+      case ParseNodeKind::Catch:
         if (!emitCatch(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_VAR:
+      case ParseNodeKind::Var:
         if (!emitDeclarationList(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_RETURN:
+      case ParseNodeKind::Return:
         if (!emitReturn(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_YIELD_STAR:
+      case ParseNodeKind::YieldStar:
         if (!emitYieldStar(pn->pn_kid))
             return false;
         break;
 
-      case ParseNodeKind::PNK_GENERATOR:
+      case ParseNodeKind::Generator:
         if (!emit1(JSOP_GENERATOR))
             return false;
         break;
 
-      case ParseNodeKind::PNK_INITIALYIELD:
+      case ParseNodeKind::InitialYield:
         if (!emitInitialYield(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_YIELD:
+      case ParseNodeKind::Yield:
         if (!emitYield(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_AWAIT:
+      case ParseNodeKind::Await:
         if (!emitAwait(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_STATEMENTLIST:
+      case ParseNodeKind::StatementList:
         if (!emitStatementList(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_SEMI:
+      case ParseNodeKind::Semi:
         if (!emitStatement(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_LABEL:
+      case ParseNodeKind::Label:
         if (!emitLabeledStatement(&pn->as<LabeledStatement>()))
             return false;
         break;
 
-      case ParseNodeKind::PNK_COMMA:
+      case ParseNodeKind::Comma:
         if (!emitSequenceExpr(pn, valueUsage))
             return false;
         break;
 
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::PowAssign:
         if (!emitAssignment(pn->pn_left, pn->getKind(), pn->pn_right))
             return false;
         break;
 
-      case ParseNodeKind::PNK_CONDITIONAL:
+      case ParseNodeKind::Conditional:
         if (!emitConditionalExpression(pn->as<ConditionalExpression>(), valueUsage))
             return false;
         break;
 
-      case ParseNodeKind::PNK_OR:
-      case ParseNodeKind::PNK_AND:
+      case ParseNodeKind::Or:
+      case ParseNodeKind::And:
         if (!emitLogical(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_ADD:
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_STRICTNE:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_INSTANCEOF:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
+      case ParseNodeKind::Add:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::StrictNe:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::In:
+      case ParseNodeKind::InstanceOf:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
         if (!emitLeftAssociative(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_POW:
+      case ParseNodeKind::Pow:
         if (!emitRightAssociative(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_PIPELINE:
+      case ParseNodeKind::Pipeline:
         if (!emitPipeline(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TYPEOFNAME:
+      case ParseNodeKind::TypeOfName:
         if (!emitTypeof(pn, JSOP_TYPEOF))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TYPEOFEXPR:
+      case ParseNodeKind::TypeOfExpr:
         if (!emitTypeof(pn, JSOP_TYPEOFEXPR))
             return false;
         break;
 
-      case ParseNodeKind::PNK_THROW:
-      case ParseNodeKind::PNK_VOID:
-      case ParseNodeKind::PNK_NOT:
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_NEG:
+      case ParseNodeKind::Throw:
+      case ParseNodeKind::Void:
+      case ParseNodeKind::Not:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Neg:
         if (!emitUnary(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PreDecrement:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PostDecrement:
         if (!emitIncOrDec(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DELETENAME:
+      case ParseNodeKind::DeleteName:
         if (!emitDeleteName(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DELETEPROP:
+      case ParseNodeKind::DeleteProp:
         if (!emitDeleteProperty(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DELETEELEM:
+      case ParseNodeKind::DeleteElem:
         if (!emitDeleteElement(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DELETEEXPR:
+      case ParseNodeKind::DeleteExpr:
         if (!emitDeleteExpression(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         if (pn->as<PropertyAccess>().isSuper()) {
             if (!emitSuperPropOp(pn, JSOP_GETPROP_SUPER))
                 return false;
         } else {
             if (!emitPropOp(pn, JSOP_GETPROP))
                 return false;
         }
         break;
 
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
         if (pn->as<PropertyByValue>().isSuper()) {
             if (!emitSuperElemOp(pn, JSOP_GETELEM_SUPER))
                 return false;
         } else {
             if (!emitElemOp(pn, JSOP_GETELEM))
                 return false;
         }
         break;
 
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_SUPERCALL:
+      case ParseNodeKind::New:
+      case ParseNodeKind::TaggedTemplate:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::SuperCall:
         if (!emitCallOrNew(pn, valueUsage))
             return false;
         break;
 
-      case ParseNodeKind::PNK_LEXICALSCOPE:
+      case ParseNodeKind::LexicalScope:
         if (!emitLexicalScope(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let:
         if (!emitDeclarationList(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_IMPORT:
+      case ParseNodeKind::Import:
         MOZ_ASSERT(sc->isModuleContext());
         break;
 
-      case ParseNodeKind::PNK_EXPORT:
+      case ParseNodeKind::Export:
         MOZ_ASSERT(sc->isModuleContext());
-        if (pn->pn_kid->getKind() != ParseNodeKind::PNK_EXPORT_SPEC_LIST) {
+        if (pn->pn_kid->getKind() != ParseNodeKind::ExportSpecList) {
             if (!emitTree(pn->pn_kid))
                 return false;
         }
         break;
 
-      case ParseNodeKind::PNK_EXPORT_DEFAULT:
+      case ParseNodeKind::ExportDefault:
         MOZ_ASSERT(sc->isModuleContext());
         if (!emitExportDefault(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_EXPORT_FROM:
+      case ParseNodeKind::ExportFrom:
         MOZ_ASSERT(sc->isModuleContext());
         break;
 
-      case ParseNodeKind::PNK_CALLSITEOBJ:
+      case ParseNodeKind::CallSiteObj:
         if (!emitCallSiteObject(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_ARRAY:
+      case ParseNodeKind::Array:
         if (!emitArrayLiteral(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_OBJECT:
+      case ParseNodeKind::Object:
         if (!emitObject(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Name:
         if (!emitGetName(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
+      case ParseNodeKind::TemplateStringList:
         if (!emitTemplateString(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_STRING:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::String:
         if (!emitAtomOp(pn, JSOP_STRING))
             return false;
         break;
 
-      case ParseNodeKind::PNK_NUMBER:
+      case ParseNodeKind::Number:
         if (!emitNumberOp(pn->pn_dval))
             return false;
         break;
 
-      case ParseNodeKind::PNK_REGEXP:
+      case ParseNodeKind::RegExp:
         if (!emitRegExp(objectList.add(pn->as<RegExpLiteral>().objbox())))
             return false;
         break;
 
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
         if (!emit1(pn->getOp()))
             return false;
         break;
 
-      case ParseNodeKind::PNK_THIS:
+      case ParseNodeKind::This:
         if (!emitThisLiteral(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_DEBUGGER:
+      case ParseNodeKind::Debugger:
         if (!updateSourceCoordNotes(pn->pn_pos.begin))
             return false;
         if (!emit1(JSOP_DEBUGGER))
             return false;
         break;
 
-      case ParseNodeKind::PNK_NOP:
+      case ParseNodeKind::Nop:
         MOZ_ASSERT(pn->getArity() == PN_NULLARY);
         break;
 
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         if (!emitClass(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_NEWTARGET:
+      case ParseNodeKind::NewTarget:
         if (!emit1(JSOP_NEWTARGET))
             return false;
         break;
 
-      case ParseNodeKind::PNK_SETTHIS:
+      case ParseNodeKind::SetThis:
         if (!emitSetThis(pn))
             return false;
         break;
 
-      case ParseNodeKind::PNK_POSHOLDER:
-        MOZ_FALLTHROUGH_ASSERT("Should never try to emit ParseNodeKind::PNK_POSHOLDER");
+      case ParseNodeKind::PosHolder:
+        MOZ_FALLTHROUGH_ASSERT("Should never try to emit ParseNodeKind::PosHolder");
 
       default:
         MOZ_ASSERT(0);
     }
 
     /* bce->emitLevel == 1 means we're last on the stack, so finish up. */
     if (emitLevel == 1) {
         if (!updateSourceCoordNotes(pn->pn_pos.end))
--- a/js/src/frontend/FoldConstants.cpp
+++ b/js/src/frontend/FoldConstants.cpp
@@ -45,17 +45,17 @@ ListContainsHoistedDeclaration(JSContext
     return true;
 }
 
 // Determines whether the given ParseNode contains any declarations whose
 // visibility will extend outside the node itself -- that is, whether the
 // ParseNode contains any var statements.
 //
 // THIS IS NOT A GENERAL-PURPOSE FUNCTION.  It is only written to work in the
-// specific context of deciding that |node|, as one arm of a ParseNodeKind::PNK_IF
+// specific context of deciding that |node|, as one arm of a ParseNodeKind::If
 // controlled by a constant condition, contains a declaration that forbids
 // |node| being completely eliminated as dead.
 static bool
 ContainsHoistedDeclaration(JSContext* cx, ParseNode* node, bool* result)
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
@@ -64,107 +64,107 @@ ContainsHoistedDeclaration(JSContext* cx
     // With a better-typed AST, we would have distinct parse node classes for
     // expressions and for statements and would characterize expressions with
     // ExpressionKind and statements with StatementKind.  Perhaps someday.  In
     // the meantime we must characterize every ParseNodeKind, even the
     // expression/sub-expression ones that, if we handle all statement kinds
     // correctly, we'll never see.
     switch (node->getKind()) {
       // Base case.
-      case ParseNodeKind::PNK_VAR:
+      case ParseNodeKind::Var:
         *result = true;
         return true;
 
       // Non-global lexical declarations are block-scoped (ergo not hoistable).
-      case ParseNodeKind::PNK_LET:
-      case ParseNodeKind::PNK_CONST:
+      case ParseNodeKind::Let:
+      case ParseNodeKind::Const:
         MOZ_ASSERT(node->isArity(PN_LIST));
         *result = false;
         return true;
 
       // Similarly to the lexical declarations above, classes cannot add hoisted
       // declarations
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         MOZ_ASSERT(node->isArity(PN_TERNARY));
         *result = false;
         return true;
 
       // Function declarations *can* be hoisted declarations.  But in the
       // magical world of the rewritten frontend, the declaration necessitated
       // by a nested function statement, not at body level, doesn't require
       // that we preserve an unreachable function declaration node against
       // dead-code removal.
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         MOZ_ASSERT(node->isArity(PN_CODE));
         *result = false;
         return true;
 
-      case ParseNodeKind::PNK_MODULE:
+      case ParseNodeKind::Module:
         *result = false;
         return true;
 
       // Statements with no sub-components at all.
-      case ParseNodeKind::PNK_NOP: // induced by function f() {} function f() {}
-      case ParseNodeKind::PNK_DEBUGGER:
+      case ParseNodeKind::Nop: // induced by function f() {} function f() {}
+      case ParseNodeKind::Debugger:
         MOZ_ASSERT(node->isArity(PN_NULLARY));
         *result = false;
         return true;
 
       // Statements containing only an expression have no declarations.
-      case ParseNodeKind::PNK_SEMI:
-      case ParseNodeKind::PNK_THROW:
-      case ParseNodeKind::PNK_RETURN:
+      case ParseNodeKind::Semi:
+      case ParseNodeKind::Throw:
+      case ParseNodeKind::Return:
         MOZ_ASSERT(node->isArity(PN_UNARY));
         *result = false;
         return true;
 
       // These two aren't statements in the spec, but we sometimes insert them
       // in statement lists anyway.
-      case ParseNodeKind::PNK_INITIALYIELD:
-      case ParseNodeKind::PNK_YIELD_STAR:
-      case ParseNodeKind::PNK_YIELD:
+      case ParseNodeKind::InitialYield:
+      case ParseNodeKind::YieldStar:
+      case ParseNodeKind::Yield:
         MOZ_ASSERT(node->isArity(PN_UNARY));
         *result = false;
         return true;
 
       // Other statements with no sub-statement components.
-      case ParseNodeKind::PNK_BREAK:
-      case ParseNodeKind::PNK_CONTINUE:
-      case ParseNodeKind::PNK_IMPORT:
-      case ParseNodeKind::PNK_IMPORT_SPEC_LIST:
-      case ParseNodeKind::PNK_IMPORT_SPEC:
-      case ParseNodeKind::PNK_EXPORT_FROM:
-      case ParseNodeKind::PNK_EXPORT_DEFAULT:
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
-      case ParseNodeKind::PNK_EXPORT_SPEC:
-      case ParseNodeKind::PNK_EXPORT:
-      case ParseNodeKind::PNK_EXPORT_BATCH_SPEC:
+      case ParseNodeKind::Break:
+      case ParseNodeKind::Continue:
+      case ParseNodeKind::Import:
+      case ParseNodeKind::ImportSpecList:
+      case ParseNodeKind::ImportSpec:
+      case ParseNodeKind::ExportFrom:
+      case ParseNodeKind::ExportDefault:
+      case ParseNodeKind::ExportSpecList:
+      case ParseNodeKind::ExportSpec:
+      case ParseNodeKind::Export:
+      case ParseNodeKind::ExportBatchSpec:
         *result = false;
         return true;
 
       // Statements possibly containing hoistable declarations only in the left
       // half, in ParseNode terms -- the loop body in AST terms.
-      case ParseNodeKind::PNK_DOWHILE:
+      case ParseNodeKind::DoWhile:
         return ContainsHoistedDeclaration(cx, node->pn_left, result);
 
       // Statements possibly containing hoistable declarations only in the
       // right half, in ParseNode terms -- the loop body or nested statement
       // (usually a block statement), in AST terms.
-      case ParseNodeKind::PNK_WHILE:
-      case ParseNodeKind::PNK_WITH:
+      case ParseNodeKind::While:
+      case ParseNodeKind::With:
         return ContainsHoistedDeclaration(cx, node->pn_right, result);
 
-      case ParseNodeKind::PNK_LABEL:
+      case ParseNodeKind::Label:
         return ContainsHoistedDeclaration(cx, node->pn_expr, result);
 
       // Statements with more complicated structures.
 
       // if-statement nodes may have hoisted declarations in their consequent
       // and alternative components.
-      case ParseNodeKind::PNK_IF: {
+      case ParseNodeKind::If: {
         MOZ_ASSERT(node->isArity(PN_TERNARY));
 
         ParseNode* consequent = node->pn_kid2;
         if (!ContainsHoistedDeclaration(cx, consequent, result))
             return false;
         if (*result)
             return true;
 
@@ -172,32 +172,32 @@ ContainsHoistedDeclaration(JSContext* cx
             goto restart;
 
         *result = false;
         return true;
       }
 
       // try-statements have statements to execute, and one or both of a
       // catch-list and a finally-block.
-      case ParseNodeKind::PNK_TRY: {
+      case ParseNodeKind::Try: {
         MOZ_ASSERT(node->isArity(PN_TERNARY));
         MOZ_ASSERT(node->pn_kid2 || node->pn_kid3,
                    "must have either catch(es) or finally");
 
         ParseNode* tryBlock = node->pn_kid1;
         if (!ContainsHoistedDeclaration(cx, tryBlock, result))
             return false;
         if (*result)
             return true;
 
         if (ParseNode* catchScope = node->pn_kid2) {
-            MOZ_ASSERT(catchScope->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
+            MOZ_ASSERT(catchScope->isKind(ParseNodeKind::LexicalScope));
 
             ParseNode* catchNode = catchScope->pn_expr;
-            MOZ_ASSERT(catchNode->isKind(ParseNodeKind::PNK_CATCH));
+            MOZ_ASSERT(catchNode->isKind(ParseNodeKind::Catch));
 
             ParseNode* catchStatements = catchNode->pn_right;
             if (!ContainsHoistedDeclaration(cx, catchStatements, result))
                 return false;
             if (*result)
                 return true;
         }
 
@@ -206,224 +206,224 @@ ContainsHoistedDeclaration(JSContext* cx
 
         *result = false;
         return true;
       }
 
       // A switch node's left half is an expression; only its right half (a
       // list of cases/defaults, or a block node) could contain hoisted
       // declarations.
-      case ParseNodeKind::PNK_SWITCH:
+      case ParseNodeKind::Switch:
         MOZ_ASSERT(node->isArity(PN_BINARY));
         return ContainsHoistedDeclaration(cx, node->pn_right, result);
 
-      case ParseNodeKind::PNK_CASE:
+      case ParseNodeKind::Case:
         return ContainsHoistedDeclaration(cx, node->as<CaseClause>().statementList(), result);
 
-      case ParseNodeKind::PNK_FOR: {
+      case ParseNodeKind::For: {
         MOZ_ASSERT(node->isArity(PN_BINARY));
 
         ParseNode* loopHead = node->pn_left;
-        MOZ_ASSERT(loopHead->isKind(ParseNodeKind::PNK_FORHEAD) ||
-                   loopHead->isKind(ParseNodeKind::PNK_FORIN) ||
-                   loopHead->isKind(ParseNodeKind::PNK_FOROF));
+        MOZ_ASSERT(loopHead->isKind(ParseNodeKind::ForHead) ||
+                   loopHead->isKind(ParseNodeKind::ForIn) ||
+                   loopHead->isKind(ParseNodeKind::ForOf));
 
-        if (loopHead->isKind(ParseNodeKind::PNK_FORHEAD)) {
+        if (loopHead->isKind(ParseNodeKind::ForHead)) {
             // for (init?; cond?; update?), with only init possibly containing
             // a hoisted declaration.  (Note: a lexical-declaration |init| is
             // (at present) hoisted in SpiderMonkey parlance -- but such
             // hoisting doesn't extend outside of this statement, so it is not
             // hoisting in the sense meant by ContainsHoistedDeclaration.)
             MOZ_ASSERT(loopHead->isArity(PN_TERNARY));
 
             ParseNode* init = loopHead->pn_kid1;
-            if (init && init->isKind(ParseNodeKind::PNK_VAR)) {
+            if (init && init->isKind(ParseNodeKind::Var)) {
                 *result = true;
                 return true;
             }
         } else {
-            MOZ_ASSERT(loopHead->isKind(ParseNodeKind::PNK_FORIN) ||
-                       loopHead->isKind(ParseNodeKind::PNK_FOROF));
+            MOZ_ASSERT(loopHead->isKind(ParseNodeKind::ForIn) ||
+                       loopHead->isKind(ParseNodeKind::ForOf));
 
             // for each? (target in ...), where only target may introduce
             // hoisted declarations.
             //
             //   -- or --
             //
             // for (target of ...), where only target may introduce hoisted
             // declarations.
             //
             // Either way, if |target| contains a declaration, it's |loopHead|'s
             // first kid.
             MOZ_ASSERT(loopHead->isArity(PN_TERNARY));
 
             ParseNode* decl = loopHead->pn_kid1;
-            if (decl && decl->isKind(ParseNodeKind::PNK_VAR)) {
+            if (decl && decl->isKind(ParseNodeKind::Var)) {
                 *result = true;
                 return true;
             }
         }
 
         ParseNode* loopBody = node->pn_right;
         return ContainsHoistedDeclaration(cx, loopBody, result);
       }
 
-      case ParseNodeKind::PNK_LEXICALSCOPE: {
+      case ParseNodeKind::LexicalScope: {
         MOZ_ASSERT(node->isArity(PN_SCOPE));
         ParseNode* expr = node->pn_expr;
 
-        if (expr->isKind(ParseNodeKind::PNK_FOR) || expr->isKind(ParseNodeKind::PNK_FUNCTION))
+        if (expr->isKind(ParseNodeKind::For) || expr->isKind(ParseNodeKind::Function))
             return ContainsHoistedDeclaration(cx, expr, result);
 
-        MOZ_ASSERT(expr->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+        MOZ_ASSERT(expr->isKind(ParseNodeKind::StatementList));
         return ListContainsHoistedDeclaration(cx, &node->pn_expr->as<ListNode>(), result);
       }
 
       // List nodes with all non-null children.
-      case ParseNodeKind::PNK_STATEMENTLIST:
+      case ParseNodeKind::StatementList:
         return ListContainsHoistedDeclaration(cx, &node->as<ListNode>(), result);
 
       // Grammar sub-components that should never be reached directly by this
       // method, because some parent component should have asserted itself.
-      case ParseNodeKind::PNK_OBJECT_PROPERTY_NAME:
-      case ParseNodeKind::PNK_COMPUTED_NAME:
-      case ParseNodeKind::PNK_SPREAD:
-      case ParseNodeKind::PNK_MUTATEPROTO:
-      case ParseNodeKind::PNK_COLON:
-      case ParseNodeKind::PNK_SHORTHAND:
-      case ParseNodeKind::PNK_CONDITIONAL:
-      case ParseNodeKind::PNK_TYPEOFNAME:
-      case ParseNodeKind::PNK_TYPEOFEXPR:
-      case ParseNodeKind::PNK_AWAIT:
-      case ParseNodeKind::PNK_VOID:
-      case ParseNodeKind::PNK_NOT:
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_DELETENAME:
-      case ParseNodeKind::PNK_DELETEPROP:
-      case ParseNodeKind::PNK_DELETEELEM:
-      case ParseNodeKind::PNK_DELETEEXPR:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_NEG:
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
-      case ParseNodeKind::PNK_OR:
-      case ParseNodeKind::PNK_AND:
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_STRICTNE:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_INSTANCEOF:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_ADD:
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
-      case ParseNodeKind::PNK_POW:
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
-      case ParseNodeKind::PNK_COMMA:
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
-      case ParseNodeKind::PNK_DOT:
-      case ParseNodeKind::PNK_ELEM:
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_NAME:
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
-      case ParseNodeKind::PNK_CALLSITEOBJ:
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_REGEXP:
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
-      case ParseNodeKind::PNK_THIS:
-      case ParseNodeKind::PNK_ELISION:
-      case ParseNodeKind::PNK_NUMBER:
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_GENERATOR:
-      case ParseNodeKind::PNK_PARAMSBODY:
-      case ParseNodeKind::PNK_CATCH:
-      case ParseNodeKind::PNK_FORIN:
-      case ParseNodeKind::PNK_FOROF:
-      case ParseNodeKind::PNK_FORHEAD:
-      case ParseNodeKind::PNK_CLASSMETHOD:
-      case ParseNodeKind::PNK_CLASSMETHODLIST:
-      case ParseNodeKind::PNK_CLASSNAMES:
-      case ParseNodeKind::PNK_NEWTARGET:
-      case ParseNodeKind::PNK_POSHOLDER:
-      case ParseNodeKind::PNK_SUPERCALL:
-      case ParseNodeKind::PNK_SUPERBASE:
-      case ParseNodeKind::PNK_SETTHIS:
+      case ParseNodeKind::ObjectPropertyName:
+      case ParseNodeKind::ComputedName:
+      case ParseNodeKind::Spread:
+      case ParseNodeKind::MutateProto:
+      case ParseNodeKind::Colon:
+      case ParseNodeKind::Shorthand:
+      case ParseNodeKind::Conditional:
+      case ParseNodeKind::TypeOfName:
+      case ParseNodeKind::TypeOfExpr:
+      case ParseNodeKind::Await:
+      case ParseNodeKind::Void:
+      case ParseNodeKind::Not:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::DeleteName:
+      case ParseNodeKind::DeleteProp:
+      case ParseNodeKind::DeleteElem:
+      case ParseNodeKind::DeleteExpr:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Neg:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PreDecrement:
+      case ParseNodeKind::PostDecrement:
+      case ParseNodeKind::Or:
+      case ParseNodeKind::And:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::StrictNe:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::InstanceOf:
+      case ParseNodeKind::In:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Add:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
+      case ParseNodeKind::Pow:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::PowAssign:
+      case ParseNodeKind::Comma:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
+      case ParseNodeKind::Dot:
+      case ParseNodeKind::Elem:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::Name:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::TemplateStringList:
+      case ParseNodeKind::TaggedTemplate:
+      case ParseNodeKind::CallSiteObj:
+      case ParseNodeKind::String:
+      case ParseNodeKind::RegExp:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
+      case ParseNodeKind::This:
+      case ParseNodeKind::Elision:
+      case ParseNodeKind::Number:
+      case ParseNodeKind::New:
+      case ParseNodeKind::Generator:
+      case ParseNodeKind::ParamsBody:
+      case ParseNodeKind::Catch:
+      case ParseNodeKind::ForIn:
+      case ParseNodeKind::ForOf:
+      case ParseNodeKind::ForHead:
+      case ParseNodeKind::ClassMethod:
+      case ParseNodeKind::ClassMethodList:
+      case ParseNodeKind::ClassNames:
+      case ParseNodeKind::NewTarget:
+      case ParseNodeKind::PosHolder:
+      case ParseNodeKind::SuperCall:
+      case ParseNodeKind::SuperBase:
+      case ParseNodeKind::SetThis:
         MOZ_CRASH("ContainsHoistedDeclaration should have indicated false on "
                   "some parent node without recurring to test this node");
 
-      case ParseNodeKind::PNK_PIPELINE:
+      case ParseNodeKind::Pipeline:
         MOZ_ASSERT(node->isArity(PN_LIST));
         *result = false;
         return true;
 
-      case ParseNodeKind::PNK_LIMIT: // invalid sentinel value
-        MOZ_CRASH("unexpected ParseNodeKind::PNK_LIMIT in node");
+      case ParseNodeKind::Limit: // invalid sentinel value
+        MOZ_CRASH("unexpected ParseNodeKind::Limit in node");
     }
 
     MOZ_CRASH("invalid node kind");
 }
 
 /*
  * Fold from one constant type to another.
  * XXX handles only strings and numbers for now
  */
 static bool
 FoldType(JSContext* cx, ParseNode* pn, ParseNodeKind kind)
 {
     if (!pn->isKind(kind)) {
         switch (kind) {
-          case ParseNodeKind::PNK_NUMBER:
-            if (pn->isKind(ParseNodeKind::PNK_STRING)) {
+          case ParseNodeKind::Number:
+            if (pn->isKind(ParseNodeKind::String)) {
                 double d;
                 if (!StringToNumber(cx, pn->pn_atom, &d))
                     return false;
                 pn->pn_dval = d;
-                pn->setKind(ParseNodeKind::PNK_NUMBER);
+                pn->setKind(ParseNodeKind::Number);
                 pn->setOp(JSOP_DOUBLE);
             }
             break;
 
-          case ParseNodeKind::PNK_STRING:
-            if (pn->isKind(ParseNodeKind::PNK_NUMBER)) {
+          case ParseNodeKind::String:
+            if (pn->isKind(ParseNodeKind::Number)) {
                 pn->pn_atom = NumberToAtom(cx, pn->pn_dval);
                 if (!pn->pn_atom)
                     return false;
-                pn->setKind(ParseNodeKind::PNK_STRING);
+                pn->setKind(ParseNodeKind::String);
                 pn->setOp(JSOP_STRING);
             }
             break;
 
           default:;
         }
     }
     return true;
@@ -441,58 +441,58 @@ ReplaceNode(ParseNode** pnp, ParseNode* 
 {
     pn->pn_next = (*pnp)->pn_next;
     *pnp = pn;
 }
 
 static bool
 IsEffectless(ParseNode* node)
 {
-    return node->isKind(ParseNodeKind::PNK_TRUE) ||
-           node->isKind(ParseNodeKind::PNK_FALSE) ||
-           node->isKind(ParseNodeKind::PNK_STRING) ||
-           node->isKind(ParseNodeKind::PNK_TEMPLATE_STRING) ||
-           node->isKind(ParseNodeKind::PNK_NUMBER) ||
-           node->isKind(ParseNodeKind::PNK_NULL) ||
-           node->isKind(ParseNodeKind::PNK_RAW_UNDEFINED) ||
-           node->isKind(ParseNodeKind::PNK_FUNCTION);
+    return node->isKind(ParseNodeKind::True) ||
+           node->isKind(ParseNodeKind::False) ||
+           node->isKind(ParseNodeKind::String) ||
+           node->isKind(ParseNodeKind::TemplateString) ||
+           node->isKind(ParseNodeKind::Number) ||
+           node->isKind(ParseNodeKind::Null) ||
+           node->isKind(ParseNodeKind::RawUndefined) ||
+           node->isKind(ParseNodeKind::Function);
 }
 
 enum Truthiness { Truthy, Falsy, Unknown };
 
 static Truthiness
 Boolish(ParseNode* pn)
 {
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_NUMBER:
+      case ParseNodeKind::Number:
         return (pn->pn_dval != 0 && !IsNaN(pn->pn_dval)) ? Truthy : Falsy;
 
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
+      case ParseNodeKind::String:
+      case ParseNodeKind::TemplateString:
         return (pn->pn_atom->length() > 0) ? Truthy : Falsy;
 
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::True:
+      case ParseNodeKind::Function:
         return Truthy;
 
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
         return Falsy;
 
-      case ParseNodeKind::PNK_VOID: {
+      case ParseNodeKind::Void: {
         // |void <foo>| evaluates to |undefined| which isn't truthy.  But the
         // sense of this method requires that the expression be literally
         // replaceable with true/false: not the case if the nested expression
         // is effectful, might throw, &c.  Walk past the |void| (and nested
         // |void| expressions, for good measure) and check that the nested
         // expression doesn't break this requirement before indicating falsity.
         do {
             pn = pn->pn_kid;
-        } while (pn->isKind(ParseNodeKind::PNK_VOID));
+        } while (pn->isKind(ParseNodeKind::Void));
 
         return IsEffectless(pn) ? Falsy : Unknown;
       }
 
       default:
         return Unknown;
     }
 }
@@ -514,117 +514,117 @@ FoldCondition(JSContext* cx, ParseNode**
     if (t != Unknown) {
         // We can turn function nodes into constant nodes here, but mutating
         // function nodes is tricky --- in particular, mutating a function node
         // that appears on a method list corrupts the method list. However,
         // methods are M's in statements of the form 'this.foo = M;', which we
         // never fold, so we're okay.
         parser.prepareNodeForMutation(node);
         if (t == Truthy) {
-            node->setKind(ParseNodeKind::PNK_TRUE);
+            node->setKind(ParseNodeKind::True);
             node->setOp(JSOP_TRUE);
         } else {
-            node->setKind(ParseNodeKind::PNK_FALSE);
+            node->setKind(ParseNodeKind::False);
             node->setOp(JSOP_FALSE);
         }
         node->setArity(PN_NULLARY);
     }
 
     return true;
 }
 
 static bool
 FoldTypeOfExpr(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_TYPEOFEXPR));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::TypeOfExpr));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode*& expr = node->pn_kid;
     if (!Fold(cx, &expr, parser))
         return false;
 
     // Constant-fold the entire |typeof| if given a constant with known type.
     RootedPropertyName result(cx);
-    if (expr->isKind(ParseNodeKind::PNK_STRING) || expr->isKind(ParseNodeKind::PNK_TEMPLATE_STRING))
+    if (expr->isKind(ParseNodeKind::String) || expr->isKind(ParseNodeKind::TemplateString))
         result = cx->names().string;
-    else if (expr->isKind(ParseNodeKind::PNK_NUMBER))
+    else if (expr->isKind(ParseNodeKind::Number))
         result = cx->names().number;
-    else if (expr->isKind(ParseNodeKind::PNK_NULL))
+    else if (expr->isKind(ParseNodeKind::Null))
         result = cx->names().object;
-    else if (expr->isKind(ParseNodeKind::PNK_TRUE) || expr->isKind(ParseNodeKind::PNK_FALSE))
+    else if (expr->isKind(ParseNodeKind::True) || expr->isKind(ParseNodeKind::False))
         result = cx->names().boolean;
-    else if (expr->isKind(ParseNodeKind::PNK_FUNCTION))
+    else if (expr->isKind(ParseNodeKind::Function))
         result = cx->names().function;
 
     if (result) {
         parser.prepareNodeForMutation(node);
 
-        node->setKind(ParseNodeKind::PNK_STRING);
+        node->setKind(ParseNodeKind::String);
         node->setArity(PN_NULLARY);
         node->setOp(JSOP_NOP);
         node->pn_atom = result;
     }
 
     return true;
 }
 
 static bool
 FoldDeleteExpr(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEEXPR));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteExpr));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode*& expr = node->pn_kid;
     if (!Fold(cx, &expr, parser))
         return false;
 
     // Expression deletion evaluates the expression, then evaluates to true.
     // For effectless expressions, eliminate the expression evaluation.
     if (IsEffectless(expr)) {
         parser.prepareNodeForMutation(node);
-        node->setKind(ParseNodeKind::PNK_TRUE);
+        node->setKind(ParseNodeKind::True);
         node->setArity(PN_NULLARY);
         node->setOp(JSOP_TRUE);
     }
 
     return true;
 }
 
 static bool
 FoldDeleteElement(JSContext* cx, ParseNode* node,
                   GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEELEM));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteElem));
     MOZ_ASSERT(node->isArity(PN_UNARY));
-    MOZ_ASSERT(node->pn_kid->isKind(ParseNodeKind::PNK_ELEM));
+    MOZ_ASSERT(node->pn_kid->isKind(ParseNodeKind::Elem));
 
     ParseNode*& expr = node->pn_kid;
     if (!Fold(cx, &expr, parser))
         return false;
 
     // If we're deleting an element, but constant-folding converted our
     // element reference into a dotted property access, we must *also*
     // morph the node's kind.
     //
     // In principle this also applies to |super["foo"] -> super.foo|,
     // but we don't constant-fold |super["foo"]| yet.
-    MOZ_ASSERT(expr->isKind(ParseNodeKind::PNK_ELEM) || expr->isKind(ParseNodeKind::PNK_DOT));
-    if (expr->isKind(ParseNodeKind::PNK_DOT))
-        node->setKind(ParseNodeKind::PNK_DELETEPROP);
+    MOZ_ASSERT(expr->isKind(ParseNodeKind::Elem) || expr->isKind(ParseNodeKind::Dot));
+    if (expr->isKind(ParseNodeKind::Dot))
+        node->setKind(ParseNodeKind::DeleteProp);
 
     return true;
 }
 
 static bool
 FoldDeleteProperty(JSContext* cx, ParseNode* node,
                    GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DELETEPROP));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::DeleteProp));
     MOZ_ASSERT(node->isArity(PN_UNARY));
-    MOZ_ASSERT(node->pn_kid->isKind(ParseNodeKind::PNK_DOT));
+    MOZ_ASSERT(node->pn_kid->isKind(ParseNodeKind::Dot));
 
     ParseNode*& expr = node->pn_kid;
 #ifdef DEBUG
     ParseNodeKind oldKind = expr->getKind();
 #endif
 
     if (!Fold(cx, &expr, parser))
         return false;
@@ -633,94 +633,94 @@ FoldDeleteProperty(JSContext* cx, ParseN
                "kind should have remained invariant under folding");
 
     return true;
 }
 
 static bool
 FoldNot(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_NOT));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Not));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode*& expr = node->pn_kid;
     if (!FoldCondition(cx, &expr, parser))
         return false;
 
-    if (expr->isKind(ParseNodeKind::PNK_NUMBER)) {
+    if (expr->isKind(ParseNodeKind::Number)) {
         double d = expr->pn_dval;
 
         parser.prepareNodeForMutation(node);
         if (d == 0 || IsNaN(d)) {
-            node->setKind(ParseNodeKind::PNK_TRUE);
+            node->setKind(ParseNodeKind::True);
             node->setOp(JSOP_TRUE);
         } else {
-            node->setKind(ParseNodeKind::PNK_FALSE);
+            node->setKind(ParseNodeKind::False);
             node->setOp(JSOP_FALSE);
         }
         node->setArity(PN_NULLARY);
-    } else if (expr->isKind(ParseNodeKind::PNK_TRUE) || expr->isKind(ParseNodeKind::PNK_FALSE)) {
-        bool newval = !expr->isKind(ParseNodeKind::PNK_TRUE);
+    } else if (expr->isKind(ParseNodeKind::True) || expr->isKind(ParseNodeKind::False)) {
+        bool newval = !expr->isKind(ParseNodeKind::True);
 
         parser.prepareNodeForMutation(node);
-        node->setKind(newval ? ParseNodeKind::PNK_TRUE : ParseNodeKind::PNK_FALSE);
+        node->setKind(newval ? ParseNodeKind::True : ParseNodeKind::False);
         node->setArity(PN_NULLARY);
         node->setOp(newval ? JSOP_TRUE : JSOP_FALSE);
     }
 
     return true;
 }
 
 static bool
 FoldUnaryArithmetic(JSContext* cx, ParseNode* node,
                     GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_BITNOT) ||
-               node->isKind(ParseNodeKind::PNK_POS) ||
-               node->isKind(ParseNodeKind::PNK_NEG),
+    MOZ_ASSERT(node->isKind(ParseNodeKind::BitNot) ||
+               node->isKind(ParseNodeKind::Pos) ||
+               node->isKind(ParseNodeKind::Neg),
                "need a different method for this node kind");
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode*& expr = node->pn_kid;
     if (!Fold(cx, &expr, parser))
         return false;
 
-    if (expr->isKind(ParseNodeKind::PNK_NUMBER) ||
-        expr->isKind(ParseNodeKind::PNK_TRUE) ||
-        expr->isKind(ParseNodeKind::PNK_FALSE))
+    if (expr->isKind(ParseNodeKind::Number) ||
+        expr->isKind(ParseNodeKind::True) ||
+        expr->isKind(ParseNodeKind::False))
     {
-        double d = expr->isKind(ParseNodeKind::PNK_NUMBER)
+        double d = expr->isKind(ParseNodeKind::Number)
                    ? expr->pn_dval
-                   : double(expr->isKind(ParseNodeKind::PNK_TRUE));
+                   : double(expr->isKind(ParseNodeKind::True));
 
-        if (node->isKind(ParseNodeKind::PNK_BITNOT))
+        if (node->isKind(ParseNodeKind::BitNot))
             d = ~ToInt32(d);
-        else if (node->isKind(ParseNodeKind::PNK_NEG))
+        else if (node->isKind(ParseNodeKind::Neg))
             d = -d;
         else
-            MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_POS)); // nothing to do
+            MOZ_ASSERT(node->isKind(ParseNodeKind::Pos)); // nothing to do
 
         parser.prepareNodeForMutation(node);
-        node->setKind(ParseNodeKind::PNK_NUMBER);
+        node->setKind(ParseNodeKind::Number);
         node->setOp(JSOP_DOUBLE);
         node->setArity(PN_NULLARY);
         node->pn_dval = d;
     }
 
     return true;
 }
 
 static bool
 FoldIncrementDecrement(JSContext* cx, ParseNode* node,
                        GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_PREINCREMENT) ||
-               node->isKind(ParseNodeKind::PNK_POSTINCREMENT) ||
-               node->isKind(ParseNodeKind::PNK_PREDECREMENT) ||
-               node->isKind(ParseNodeKind::PNK_POSTDECREMENT));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::PreIncrement) ||
+               node->isKind(ParseNodeKind::PostIncrement) ||
+               node->isKind(ParseNodeKind::PreDecrement) ||
+               node->isKind(ParseNodeKind::PostDecrement));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     ParseNode*& target = node->pn_kid;
     MOZ_ASSERT(parser.isValidSimpleAssignmentTarget(target, PermitAssignmentToFunctionCalls));
 
     if (!Fold(cx, &target, parser))
         return false;
 
@@ -729,20 +729,20 @@ FoldIncrementDecrement(JSContext* cx, Pa
     return true;
 }
 
 static bool
 FoldAndOr(JSContext* cx, ParseNode** nodePtr, GeneralParser<FullParseHandler, char16_t>& parser)
 {
     ParseNode* node = *nodePtr;
 
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_AND) || node->isKind(ParseNodeKind::PNK_OR));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::And) || node->isKind(ParseNodeKind::Or));
     MOZ_ASSERT(node->isArity(PN_LIST));
 
-    bool isOrNode = node->isKind(ParseNodeKind::PNK_OR);
+    bool isOrNode = node->isKind(ParseNodeKind::Or);
     ParseNode** elem = &node->pn_head;
     do {
         if (!Fold(cx, elem, parser))
             return false;
 
         Truthiness t = Boolish(*elem);
 
         // If we don't know the constant-folded node's truthiness, we can't
@@ -798,17 +798,17 @@ FoldAndOr(JSContext* cx, ParseNode** nod
     node->checkListConsistency();
 
     // If we removed nodes, we may have to replace a one-element list with
     // its element.
     if (node->pn_count == 1) {
         ParseNode* first = node->pn_head;
         ReplaceNode(nodePtr, first);
 
-        node->setKind(ParseNodeKind::PNK_NULL);
+        node->setKind(ParseNodeKind::Null);
         node->setArity(PN_NULLARY);
         parser.freeTree(node);
     }
 
     return true;
 }
 
 static bool
@@ -820,17 +820,17 @@ FoldConditional(JSContext* cx, ParseNode
     do {
         // |nextNode| on entry points to the C?T:F expression to be folded.
         // Reset it to exit the loop in the common case where F isn't another
         // ?: expression.
         nodePtr = nextNode;
         nextNode = nullptr;
 
         ParseNode* node = *nodePtr;
-        MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_CONDITIONAL));
+        MOZ_ASSERT(node->isKind(ParseNodeKind::Conditional));
         MOZ_ASSERT(node->isArity(PN_TERNARY));
 
         ParseNode*& expr = node->pn_kid1;
         if (!FoldCondition(cx, &expr, parser))
             return false;
 
         ParseNode*& ifTruthy = node->pn_kid2;
         if (!Fold(cx, &ifTruthy, parser))
@@ -840,17 +840,17 @@ FoldConditional(JSContext* cx, ParseNode
 
         // If our C?T:F node has F as another ?: node, *iteratively* constant-
         // fold F *after* folding C and T (and possibly eliminating C and one
         // of T/F entirely); otherwise fold F normally.  Making |nextNode| non-
         // null causes this loop to run again to fold F.
         //
         // Conceivably we could instead/also iteratively constant-fold T, if T
         // were more complex than F.  Such an optimization is unimplemented.
-        if (ifFalsy->isKind(ParseNodeKind::PNK_CONDITIONAL)) {
+        if (ifFalsy->isKind(ParseNodeKind::Conditional)) {
             nextNode = &ifFalsy;
         } else {
             if (!Fold(cx, &ifFalsy, parser))
                 return false;
         }
 
         // Try to constant-fold based on the condition expression.
         Truthiness t = Boolish(expr);
@@ -888,17 +888,17 @@ FoldIf(JSContext* cx, ParseNode** nodePt
 
     do {
         // |nextNode| on entry points to the initial |if| to be folded.  Reset
         // it to exit the loop when the |else| arm isn't another |if|.
         nodePtr = nextNode;
         nextNode = nullptr;
 
         ParseNode* node = *nodePtr;
-        MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_IF));
+        MOZ_ASSERT(node->isKind(ParseNodeKind::If));
         MOZ_ASSERT(node->isArity(PN_TERNARY));
 
         ParseNode*& expr = node->pn_kid1;
         if (!FoldCondition(cx, &expr, parser))
             return false;
 
         ParseNode*& consequent = node->pn_kid2;
         if (!Fold(cx, &consequent, parser))
@@ -906,17 +906,17 @@ FoldIf(JSContext* cx, ParseNode** nodePt
 
         ParseNode*& alternative = node->pn_kid3;
         if (alternative) {
             // If in |if (C) T; else F;| we have |F| as another |if|,
             // *iteratively* constant-fold |F| *after* folding |C| and |T| (and
             // possibly completely replacing the whole thing with |T| or |F|);
             // otherwise fold F normally.  Making |nextNode| non-null causes
             // this loop to run again to fold F.
-            if (alternative->isKind(ParseNodeKind::PNK_IF)) {
+            if (alternative->isKind(ParseNodeKind::If)) {
                 nextNode = &alternative;
             } else {
                 if (!Fold(cx, &alternative, parser))
                     return false;
             }
         }
 
         // Eliminate the consequent or alternative if the condition has
@@ -951,46 +951,46 @@ FoldIf(JSContext* cx, ParseNode** nodePt
         if (!performReplacement)
             continue;
 
         if (!replacement) {
             // If there's no replacement node, we have a constantly-false |if|
             // with no |else|.  Replace the entire thing with an empty
             // statement list.
             parser.prepareNodeForMutation(node);
-            node->setKind(ParseNodeKind::PNK_STATEMENTLIST);
+            node->setKind(ParseNodeKind::StatementList);
             node->setArity(PN_LIST);
             node->makeEmpty();
         } else {
             // Replacement invalidates |nextNode|, so reset it (if the
             // replacement requires folding) or clear it (if |alternative|
             // is dead code) as needed.
             if (nextNode)
                 nextNode = (*nextNode == replacement) ? nodePtr : nullptr;
             ReplaceNode(nodePtr, replacement);
 
             // Morph the original node into a discardable node, then
             // aggressively free it and the discarded arm (if any) to suss out
             // any bugs in the preceding logic.
-            node->setKind(ParseNodeKind::PNK_STATEMENTLIST);
+            node->setKind(ParseNodeKind::StatementList);
             node->setArity(PN_LIST);
             node->makeEmpty();
             if (discarded)
                 node->append(discarded);
             parser.freeTree(node);
         }
     } while (nextNode);
 
     return true;
 }
 
 static bool
 FoldFunction(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_FUNCTION));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Function));
     MOZ_ASSERT(node->isArity(PN_CODE));
 
     // Don't constant-fold inside "use asm" code, as this could create a parse
     // tree that doesn't type-check as asm.js.
     if (node->pn_funbox->useAsmOrInsideUseAsm())
         return true;
 
     // Note: pn_body is null for lazily-parsed functions.
@@ -1000,176 +1000,176 @@ FoldFunction(JSContext* cx, ParseNode* n
     }
 
     return true;
 }
 
 static double
 ComputeBinary(ParseNodeKind kind, double left, double right)
 {
-    if (kind == ParseNodeKind::PNK_ADD)
+    if (kind == ParseNodeKind::Add)
         return left + right;
 
-    if (kind == ParseNodeKind::PNK_SUB)
+    if (kind == ParseNodeKind::Sub)
         return left - right;
 
-    if (kind == ParseNodeKind::PNK_STAR)
+    if (kind == ParseNodeKind::Star)
         return left * right;
 
-    if (kind == ParseNodeKind::PNK_MOD)
+    if (kind == ParseNodeKind::Mod)
         return right == 0 ? GenericNaN() : js_fmod(left, right);
 
-    if (kind == ParseNodeKind::PNK_URSH)
+    if (kind == ParseNodeKind::Ursh)
         return ToUint32(left) >> (ToUint32(right) & 31);
 
-    if (kind == ParseNodeKind::PNK_DIV) {
+    if (kind == ParseNodeKind::Div) {
         if (right == 0) {
 #if defined(XP_WIN)
             /* XXX MSVC miscompiles such that (NaN == 0) */
             if (IsNaN(right))
                 return GenericNaN();
 #endif
             if (left == 0 || IsNaN(left))
                 return GenericNaN();
             if (IsNegative(left) != IsNegative(right))
                 return NegativeInfinity<double>();
             return PositiveInfinity<double>();
         }
 
         return left / right;
     }
 
-    MOZ_ASSERT(kind == ParseNodeKind::PNK_LSH || kind == ParseNodeKind::PNK_RSH);
+    MOZ_ASSERT(kind == ParseNodeKind::Lsh || kind == ParseNodeKind::Rsh);
 
     int32_t i = ToInt32(left);
     uint32_t j = ToUint32(right) & 31;
-    return int32_t((kind == ParseNodeKind::PNK_LSH) ? uint32_t(i) << j : i >> j);
+    return int32_t((kind == ParseNodeKind::Lsh) ? uint32_t(i) << j : i >> j);
 }
 
 static bool
 FoldModule(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_MODULE));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Module));
     MOZ_ASSERT(node->isArity(PN_CODE));
 
     ParseNode*& moduleBody = node->pn_body;
     MOZ_ASSERT(moduleBody);
     return Fold(cx, &moduleBody, parser);
 }
 
 static bool
 FoldBinaryArithmetic(JSContext* cx, ParseNode* node,
                      GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_SUB) ||
-               node->isKind(ParseNodeKind::PNK_STAR) ||
-               node->isKind(ParseNodeKind::PNK_LSH) ||
-               node->isKind(ParseNodeKind::PNK_RSH) ||
-               node->isKind(ParseNodeKind::PNK_URSH) ||
-               node->isKind(ParseNodeKind::PNK_DIV) ||
-               node->isKind(ParseNodeKind::PNK_MOD));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Sub) ||
+               node->isKind(ParseNodeKind::Star) ||
+               node->isKind(ParseNodeKind::Lsh) ||
+               node->isKind(ParseNodeKind::Rsh) ||
+               node->isKind(ParseNodeKind::Ursh) ||
+               node->isKind(ParseNodeKind::Div) ||
+               node->isKind(ParseNodeKind::Mod));
     MOZ_ASSERT(node->isArity(PN_LIST));
     MOZ_ASSERT(node->pn_count >= 2);
 
     // Fold each operand, ideally into a number.
     ParseNode** listp = &node->pn_head;
     for (; *listp; listp = &(*listp)->pn_next) {
         if (!Fold(cx, listp, parser))
             return false;
 
-        if (!FoldType(cx, *listp, ParseNodeKind::PNK_NUMBER))
+        if (!FoldType(cx, *listp, ParseNodeKind::Number))
             return false;
     }
 
     // Repoint the list's tail pointer.
     node->pn_tail = listp;
 
     // Now fold all leading numeric terms together into a single number.
     // (Trailing terms for the non-shift operations can't be folded together
     // due to floating point imprecision.  For example, if |x === -2**53|,
     // |x - 1 - 1 === -2**53| but |x - 2 === -2**53 - 2|.  Shifts could be
     // folded, but it doesn't seem worth the effort.)
     ParseNode* elem = node->pn_head;
     ParseNode* next = elem->pn_next;
-    if (elem->isKind(ParseNodeKind::PNK_NUMBER)) {
+    if (elem->isKind(ParseNodeKind::Number)) {
         ParseNodeKind kind = node->getKind();
         while (true) {
-            if (!next || !next->isKind(ParseNodeKind::PNK_NUMBER))
+            if (!next || !next->isKind(ParseNodeKind::Number))
                 break;
 
             double d = ComputeBinary(kind, elem->pn_dval, next->pn_dval);
 
             ParseNode* afterNext = next->pn_next;
             parser.freeTree(next);
             next = afterNext;
             elem->pn_next = next;
 
-            elem->setKind(ParseNodeKind::PNK_NUMBER);
+            elem->setKind(ParseNodeKind::Number);
             elem->setOp(JSOP_DOUBLE);
             elem->setArity(PN_NULLARY);
             elem->pn_dval = d;
 
             node->pn_count--;
         }
 
         if (node->pn_count == 1) {
             MOZ_ASSERT(node->pn_head == elem);
-            MOZ_ASSERT(elem->isKind(ParseNodeKind::PNK_NUMBER));
+            MOZ_ASSERT(elem->isKind(ParseNodeKind::Number));
 
             double d = elem->pn_dval;
-            node->setKind(ParseNodeKind::PNK_NUMBER);
+            node->setKind(ParseNodeKind::Number);
             node->setArity(PN_NULLARY);
             node->setOp(JSOP_DOUBLE);
             node->pn_dval = d;
 
             parser.freeTree(elem);
         }
     }
 
     return true;
 }
 
 static bool
 FoldExponentiation(JSContext* cx, ParseNode* node,
                    GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_POW));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Pow));
     MOZ_ASSERT(node->isArity(PN_LIST));
     MOZ_ASSERT(node->pn_count >= 2);
 
     // Fold each operand, ideally into a number.
     ParseNode** listp = &node->pn_head;
     for (; *listp; listp = &(*listp)->pn_next) {
         if (!Fold(cx, listp, parser))
             return false;
 
-        if (!FoldType(cx, *listp, ParseNodeKind::PNK_NUMBER))
+        if (!FoldType(cx, *listp, ParseNodeKind::Number))
             return false;
     }
 
     // Repoint the list's tail pointer.
     node->pn_tail = listp;
 
     // Unlike all other binary arithmetic operators, ** is right-associative:
     // 2**3**5 is 2**(3**5), not (2**3)**5.  As list nodes singly-link their
     // children, full constant-folding requires either linear space or dodgy
     // in-place linked list reversal.  So we only fold one exponentiation: it's
     // easy and addresses common cases like |2**32|.
     if (node->pn_count > 2)
         return true;
 
     ParseNode* base = node->pn_head;
     ParseNode* exponent = base->pn_next;
-    if (!base->isKind(ParseNodeKind::PNK_NUMBER) || !exponent->isKind(ParseNodeKind::PNK_NUMBER))
+    if (!base->isKind(ParseNodeKind::Number) || !exponent->isKind(ParseNodeKind::Number))
         return true;
 
     double d1 = base->pn_dval, d2 = exponent->pn_dval;
 
     parser.prepareNodeForMutation(node);
-    node->setKind(ParseNodeKind::PNK_NUMBER);
+    node->setKind(ParseNodeKind::Number);
     node->setArity(PN_NULLARY);
     node->setOp(JSOP_DOUBLE);
     node->pn_dval = ecmaPow(d1, d2);
     return true;
 }
 
 static bool
 FoldList(JSContext* cx, ParseNode* list, GeneralParser<FullParseHandler, char16_t>& parser)
@@ -1188,31 +1188,31 @@ FoldList(JSContext* cx, ParseNode* list,
     list->checkListConsistency();
 
     return true;
 }
 
 static bool
 FoldReturn(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_RETURN));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Return));
     MOZ_ASSERT(node->isArity(PN_UNARY));
 
     if (ParseNode*& expr = node->pn_kid) {
         if (!Fold(cx, &expr, parser))
             return false;
     }
 
     return true;
 }
 
 static bool
 FoldTry(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_TRY));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Try));
     MOZ_ASSERT(node->isArity(PN_TERNARY));
 
     ParseNode*& statements = node->pn_kid1;
     if (!Fold(cx, &statements, parser))
         return false;
 
     if (ParseNode*& catchScope = node->pn_kid2) {
         if (!Fold(cx, &catchScope, parser))
@@ -1225,17 +1225,17 @@ FoldTry(JSContext* cx, ParseNode* node, 
     }
 
     return true;
 }
 
 static bool
 FoldCatch(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_CATCH));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Catch));
     MOZ_ASSERT(node->isArity(PN_BINARY));
 
     if (ParseNode*& declPattern = node->pn_left) {
         if (!Fold(cx, &declPattern, parser))
             return false;
     }
 
     if (ParseNode*& statements = node->pn_right) {
@@ -1244,17 +1244,17 @@ FoldCatch(JSContext* cx, ParseNode* node
     }
 
     return true;
 }
 
 static bool
 FoldClass(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_CLASS));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Class));
     MOZ_ASSERT(node->isArity(PN_TERNARY));
 
     if (ParseNode*& classNames = node->pn_kid1) {
         if (!Fold(cx, &classNames, parser))
             return false;
     }
 
     if (ParseNode*& heritage = node->pn_kid2) {
@@ -1266,42 +1266,42 @@ FoldClass(JSContext* cx, ParseNode* node
     return Fold(cx, &body, parser);
 }
 
 static bool
 FoldElement(JSContext* cx, ParseNode** nodePtr, GeneralParser<FullParseHandler, char16_t>& parser)
 {
     ParseNode* node = *nodePtr;
 
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_ELEM));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Elem));
     MOZ_ASSERT(node->isArity(PN_BINARY));
 
     ParseNode*& expr = node->pn_left;
     if (!Fold(cx, &expr, parser))
         return false;
 
     ParseNode*& key = node->pn_right;
     if (!Fold(cx, &key, parser))
         return false;
 
     PropertyName* name = nullptr;
-    if (key->isKind(ParseNodeKind::PNK_STRING)) {
+    if (key->isKind(ParseNodeKind::String)) {
         JSAtom* atom = key->pn_atom;
         uint32_t index;
 
         if (atom->isIndex(&index)) {
             // Optimization 1: We have something like expr["100"]. This is
             // equivalent to expr[100] which is faster.
-            key->setKind(ParseNodeKind::PNK_NUMBER);
+            key->setKind(ParseNodeKind::Number);
             key->setOp(JSOP_DOUBLE);
             key->pn_dval = index;
         } else {
             name = atom->asPropertyName();
         }
-    } else if (key->isKind(ParseNodeKind::PNK_NUMBER)) {
+    } else if (key->isKind(ParseNodeKind::Number)) {
         double number = key->pn_dval;
         if (number != ToUint32(number)) {
             // Optimization 2: We have something like expr[3.14]. The number
             // isn't an array index, so it converts to a string ("3.14"),
             // enabling optimization 3 below.
             JSAtom* atom = ToAtom<NoGC>(cx, DoubleValue(number));
             if (!atom)
                 return false;
@@ -1321,48 +1321,48 @@ FoldElement(JSContext* cx, ParseNode** n
     dottedAccess->setInParens(node->isInParens());
     ReplaceNode(nodePtr, dottedAccess);
 
     // If we've replaced |expr["prop"]| with |expr.prop|, we can now free the
     // |"prop"| and |expr["prop"]| nodes -- but not the |expr| node that we're
     // now using as a sub-node of |dottedAccess|.  Munge |expr["prop"]| into a
     // node with |"prop"| as its only child, that'll pass AST sanity-checking
     // assertions during freeing, then free it.
-    node->setKind(ParseNodeKind::PNK_TYPEOFEXPR);
+    node->setKind(ParseNodeKind::TypeOfExpr);
     node->setArity(PN_UNARY);
     node->pn_kid = key;
     parser.freeTree(node);
 
     return true;
 }
 
 static bool
 FoldAdd(JSContext* cx, ParseNode** nodePtr, GeneralParser<FullParseHandler, char16_t>& parser)
 {
     ParseNode* node = *nodePtr;
 
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_ADD));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Add));
     MOZ_ASSERT(node->isArity(PN_LIST));
     MOZ_ASSERT(node->pn_count >= 2);
 
     // Generically fold all operands first.
     if (!FoldList(cx, node, parser))
         return false;
 
     // Fold leading numeric operands together:
     //
     //   (1 + 2 + x)  becomes  (3 + x)
     //
     // Don't go past the leading operands: additions after a string are
     // string concatenations, not additions: ("1" + 2 + 3 === "123").
     ParseNode* current = node->pn_head;
     ParseNode* next = current->pn_next;
-    if (current->isKind(ParseNodeKind::PNK_NUMBER)) {
+    if (current->isKind(ParseNodeKind::Number)) {
         do {
-            if (!next->isKind(ParseNodeKind::PNK_NUMBER))
+            if (!next->isKind(ParseNodeKind::Number))
                 break;
 
             current->pn_dval += next->pn_dval;
             current->pn_next = next->pn_next;
             parser.freeTree(next);
             next = current->pn_next;
 
             MOZ_ASSERT(node->pn_count > 1);
@@ -1373,53 +1373,53 @@ FoldAdd(JSContext* cx, ParseNode** nodeP
     // If any operands remain, attempt string concatenation folding.
     do {
         // If no operands remain, we're done.
         if (!next)
             break;
 
         // (number + string) is string concatenation *only* at the start of
         // the list: (x + 1 + "2" !== x + "12") when x is a number.
-        if (current->isKind(ParseNodeKind::PNK_NUMBER) && next->isKind(ParseNodeKind::PNK_STRING)) {
-            if (!FoldType(cx, current, ParseNodeKind::PNK_STRING))
+        if (current->isKind(ParseNodeKind::Number) && next->isKind(ParseNodeKind::String)) {
+            if (!FoldType(cx, current, ParseNodeKind::String))
                 return false;
             next = current->pn_next;
         }
 
         // The first string forces all subsequent additions to be
         // string concatenations.
         do {
-            if (current->isKind(ParseNodeKind::PNK_STRING))
+            if (current->isKind(ParseNodeKind::String))
                 break;
 
             current = next;
             next = next->pn_next;
         } while (next);
 
         // If there's nothing left to fold, we're done.
         if (!next)
             break;
 
         RootedString combination(cx);
         RootedString tmp(cx);
         do {
             // Create a rope of the current string and all succeeding
             // constants that we can convert to strings, then atomize it
             // and replace them all with that fresh string.
-            MOZ_ASSERT(current->isKind(ParseNodeKind::PNK_STRING));
+            MOZ_ASSERT(current->isKind(ParseNodeKind::String));
 
             combination = current->pn_atom;
 
             do {
                 // Try folding the next operand to a string.
-                if (!FoldType(cx, next, ParseNodeKind::PNK_STRING))
+                if (!FoldType(cx, next, ParseNodeKind::String))
                     return false;
 
                 // Stop glomming once folding doesn't produce a string.
-                if (!next->isKind(ParseNodeKind::PNK_STRING))
+                if (!next->isKind(ParseNodeKind::String))
                     break;
 
                 // Add this string to the combination and remove the node.
                 tmp = next->pn_atom;
                 combination = ConcatStrings<CanGC>(cx, combination, tmp);
                 if (!combination)
                     return false;
 
@@ -1427,17 +1427,17 @@ FoldAdd(JSContext* cx, ParseNode** nodeP
                 parser.freeTree(next);
                 next = current->pn_next;
 
                 MOZ_ASSERT(node->pn_count > 1);
                 node->pn_count--;
             } while (next);
 
             // Replace |current|'s string with the entire combination.
-            MOZ_ASSERT(current->isKind(ParseNodeKind::PNK_STRING));
+            MOZ_ASSERT(current->isKind(ParseNodeKind::String));
             combination = AtomizeString(cx, combination);
             if (!combination)
                 return false;
             current->pn_atom = &combination->asAtom();
 
 
             // If we're out of nodes, we're done.
             if (!next)
@@ -1451,50 +1451,50 @@ FoldAdd(JSContext* cx, ParseNode** nodeP
             if (!next)
                 break;
 
             // Otherwise find the next node foldable to a string, and loop.
             do {
                 current = next;
                 next = current->pn_next;
 
-                if (!FoldType(cx, current, ParseNodeKind::PNK_STRING))
+                if (!FoldType(cx, current, ParseNodeKind::String))
                     return false;
                 next = current->pn_next;
-            } while (!current->isKind(ParseNodeKind::PNK_STRING) && next);
+            } while (!current->isKind(ParseNodeKind::String) && next);
         } while (next);
     } while (false);
 
     MOZ_ASSERT(!next, "must have considered all nodes here");
     MOZ_ASSERT(!current->pn_next, "current node must be the last node");
 
     node->pn_tail = &current->pn_next;
     node->checkListConsistency();
 
     if (node->pn_count == 1) {
-        // We reduced the list to a constant.  Replace the ParseNodeKind::PNK_ADD node
+        // We reduced the list to a constant.  Replace the ParseNodeKind::Add node
         // with that constant.
         ReplaceNode(nodePtr, current);
 
         // Free the old node to aggressively verify nothing uses it.
-        node->setKind(ParseNodeKind::PNK_TRUE);
+        node->setKind(ParseNodeKind::True);
         node->setArity(PN_NULLARY);
         node->setOp(JSOP_TRUE);
         parser.freeTree(node);
     }
 
     return true;
 }
 
 static bool
 FoldCall(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_CALL) ||
-               node->isKind(ParseNodeKind::PNK_SUPERCALL) ||
-               node->isKind(ParseNodeKind::PNK_TAGGED_TEMPLATE));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Call) ||
+               node->isKind(ParseNodeKind::SuperCall) ||
+               node->isKind(ParseNodeKind::TaggedTemplate));
     MOZ_ASSERT(node->isArity(PN_LIST));
 
     // Don't fold a parenthesized callable component in an invocation, as this
     // might cause a different |this| value to be used, changing semantics:
     //
     //   var prop = "global";
     //   var obj = { prop: "obj", f: function() { return this.prop; } };
     //   assertEq((true ? obj.f : null)(), "global");
@@ -1517,41 +1517,41 @@ FoldCall(JSContext* cx, ParseNode* node,
 
     node->checkListConsistency();
     return true;
 }
 
 static bool
 FoldForInOrOf(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_FORIN) ||
-               node->isKind(ParseNodeKind::PNK_FOROF));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::ForIn) ||
+               node->isKind(ParseNodeKind::ForOf));
     MOZ_ASSERT(node->isArity(PN_TERNARY));
     MOZ_ASSERT(!node->pn_kid2);
 
     return Fold(cx, &node->pn_kid1, parser) &&
            Fold(cx, &node->pn_kid3, parser);
 }
 
 static bool
 FoldForHead(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_FORHEAD));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::ForHead));
     MOZ_ASSERT(node->isArity(PN_TERNARY));
 
     if (ParseNode*& init = node->pn_kid1) {
         if (!Fold(cx, &init, parser))
             return false;
     }
 
     if (ParseNode*& test = node->pn_kid2) {
         if (!FoldCondition(cx, &test, parser))
             return false;
 
-        if (test->isKind(ParseNodeKind::PNK_TRUE)) {
+        if (test->isKind(ParseNodeKind::True)) {
             parser.freeTree(test);
             test = nullptr;
         }
     }
 
     if (ParseNode*& update = node->pn_kid3) {
         if (!Fold(cx, &update, parser))
             return false;
@@ -1559,34 +1559,34 @@ FoldForHead(JSContext* cx, ParseNode* no
 
     return true;
 }
 
 static bool
 FoldDottedProperty(JSContext* cx, ParseNode* node,
                    GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_DOT));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Dot));
     MOZ_ASSERT(node->isArity(PN_NAME));
 
     // Iterate through a long chain of dotted property accesses to find the
     // most-nested non-dotted property node, then fold that.
     ParseNode** nested = &node->pn_expr;
-    while ((*nested)->isKind(ParseNodeKind::PNK_DOT)) {
+    while ((*nested)->isKind(ParseNodeKind::Dot)) {
         MOZ_ASSERT((*nested)->isArity(PN_NAME));
         nested = &(*nested)->pn_expr;
     }
 
     return Fold(cx, nested, parser);
 }
 
 static bool
 FoldName(JSContext* cx, ParseNode* node, GeneralParser<FullParseHandler, char16_t>& parser)
 {
-    MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_NAME));
+    MOZ_ASSERT(node->isKind(ParseNodeKind::Name));
     MOZ_ASSERT(node->isArity(PN_NAME));
 
     if (!node->pn_expr)
         return true;
 
     return Fold(cx, &node->pn_expr, parser);
 }
 
@@ -1594,289 +1594,289 @@ bool
 Fold(JSContext* cx, ParseNode** pnp, GeneralParser<FullParseHandler, char16_t>& parser)
 {
     if (!CheckRecursionLimit(cx))
         return false;
 
     ParseNode* pn = *pnp;
 
     switch (pn->getKind()) {
-      case ParseNodeKind::PNK_NOP:
-      case ParseNodeKind::PNK_REGEXP:
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
-      case ParseNodeKind::PNK_ELISION:
-      case ParseNodeKind::PNK_NUMBER:
-      case ParseNodeKind::PNK_DEBUGGER:
-      case ParseNodeKind::PNK_BREAK:
-      case ParseNodeKind::PNK_CONTINUE:
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_GENERATOR:
-      case ParseNodeKind::PNK_EXPORT_BATCH_SPEC:
-      case ParseNodeKind::PNK_OBJECT_PROPERTY_NAME:
-      case ParseNodeKind::PNK_POSHOLDER:
+      case ParseNodeKind::Nop:
+      case ParseNodeKind::RegExp:
+      case ParseNodeKind::String:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
+      case ParseNodeKind::Elision:
+      case ParseNodeKind::Number:
+      case ParseNodeKind::Debugger:
+      case ParseNodeKind::Break:
+      case ParseNodeKind::Continue:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::Generator:
+      case ParseNodeKind::ExportBatchSpec:
+      case ParseNodeKind::ObjectPropertyName:
+      case ParseNodeKind::PosHolder:
         MOZ_ASSERT(pn->isArity(PN_NULLARY));
         return true;
 
-      case ParseNodeKind::PNK_SUPERBASE:
-      case ParseNodeKind::PNK_TYPEOFNAME:
+      case ParseNodeKind::SuperBase:
+      case ParseNodeKind::TypeOfName:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
-        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Name));
         MOZ_ASSERT(!pn->pn_kid->expr());
         return true;
 
-      case ParseNodeKind::PNK_TYPEOFEXPR:
+      case ParseNodeKind::TypeOfExpr:
         return FoldTypeOfExpr(cx, pn, parser);
 
-      case ParseNodeKind::PNK_DELETENAME: {
+      case ParseNodeKind::DeleteName: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
-        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Name));
         return true;
       }
 
-      case ParseNodeKind::PNK_DELETEEXPR:
+      case ParseNodeKind::DeleteExpr:
         return FoldDeleteExpr(cx, pn, parser);
 
-      case ParseNodeKind::PNK_DELETEELEM:
+      case ParseNodeKind::DeleteElem:
         return FoldDeleteElement(cx, pn, parser);
 
-      case ParseNodeKind::PNK_DELETEPROP:
+      case ParseNodeKind::DeleteProp:
         return FoldDeleteProperty(cx, pn, parser);
 
-      case ParseNodeKind::PNK_CONDITIONAL:
+      case ParseNodeKind::Conditional:
         return FoldConditional(cx, pnp, parser);
 
-      case ParseNodeKind::PNK_IF:
+      case ParseNodeKind::If:
         return FoldIf(cx, pnp, parser);
 
-      case ParseNodeKind::PNK_NOT:
+      case ParseNodeKind::Not:
         return FoldNot(cx, pn, parser);
 
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_NEG:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Neg:
         return FoldUnaryArithmetic(cx, pn, parser);
 
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PreDecrement:
+      case ParseNodeKind::PostDecrement:
         return FoldIncrementDecrement(cx, pn, parser);
 
-      case ParseNodeKind::PNK_THROW:
-      case ParseNodeKind::PNK_MUTATEPROTO:
-      case ParseNodeKind::PNK_COMPUTED_NAME:
-      case ParseNodeKind::PNK_SPREAD:
-      case ParseNodeKind::PNK_EXPORT:
-      case ParseNodeKind::PNK_VOID:
+      case ParseNodeKind::Throw:
+      case ParseNodeKind::MutateProto:
+      case ParseNodeKind::ComputedName:
+      case ParseNodeKind::Spread:
+      case ParseNodeKind::Export:
+      case ParseNodeKind::Void:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         return Fold(cx, &pn->pn_kid, parser);
 
-      case ParseNodeKind::PNK_EXPORT_DEFAULT:
+      case ParseNodeKind::ExportDefault:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         return Fold(cx, &pn->pn_left, parser);
 
-      case ParseNodeKind::PNK_SEMI:
-      case ParseNodeKind::PNK_THIS:
+      case ParseNodeKind::Semi:
+      case ParseNodeKind::This:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (ParseNode*& expr = pn->pn_kid)
             return Fold(cx, &expr, parser);
         return true;
 
-      case ParseNodeKind::PNK_PIPELINE:
+      case ParseNodeKind::Pipeline:
         return true;
 
-      case ParseNodeKind::PNK_AND:
-      case ParseNodeKind::PNK_OR:
+      case ParseNodeKind::And:
+      case ParseNodeKind::Or:
         return FoldAndOr(cx, pnp, parser);
 
-      case ParseNodeKind::PNK_FUNCTION:
+      case ParseNodeKind::Function:
         return FoldFunction(cx, pn, parser);
 
-      case ParseNodeKind::PNK_MODULE:
+      case ParseNodeKind::Module:
         return FoldModule(cx, pn, parser);
 
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
         return FoldBinaryArithmetic(cx, pn, parser);
 
-      case ParseNodeKind::PNK_POW:
+      case ParseNodeKind::Pow:
         return FoldExponentiation(cx, pn, parser);
 
       // Various list nodes not requiring care to minimally fold.  Some of
       // these could be further folded/optimized, but we don't make the effort.
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_STRICTNE:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_INSTANCEOF:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_COMMA:
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
-      case ParseNodeKind::PNK_STATEMENTLIST:
-      case ParseNodeKind::PNK_CLASSMETHODLIST:
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
-      case ParseNodeKind::PNK_VAR:
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET:
-      case ParseNodeKind::PNK_PARAMSBODY:
-      case ParseNodeKind::PNK_CALLSITEOBJ:
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
-      case ParseNodeKind::PNK_IMPORT_SPEC_LIST:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::StrictNe:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::InstanceOf:
+      case ParseNodeKind::In:
+      case ParseNodeKind::Comma:
+      case ParseNodeKind::New:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
+      case ParseNodeKind::StatementList:
+      case ParseNodeKind::ClassMethodList:
+      case ParseNodeKind::TemplateStringList:
+      case ParseNodeKind::Var:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let:
+      case ParseNodeKind::ParamsBody:
+      case ParseNodeKind::CallSiteObj:
+      case ParseNodeKind::ExportSpecList:
+      case ParseNodeKind::ImportSpecList:
         return FoldList(cx, pn, parser);
 
-      case ParseNodeKind::PNK_INITIALYIELD:
+      case ParseNodeKind::InitialYield:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
-        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_ASSIGN) &&
-                   pn->pn_kid->pn_left->isKind(ParseNodeKind::PNK_NAME) &&
-                   pn->pn_kid->pn_right->isKind(ParseNodeKind::PNK_GENERATOR));
+        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Assign) &&
+                   pn->pn_kid->pn_left->isKind(ParseNodeKind::Name) &&
+                   pn->pn_kid->pn_right->isKind(ParseNodeKind::Generator));
         return true;
 
-      case ParseNodeKind::PNK_YIELD_STAR:
+      case ParseNodeKind::YieldStar:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         return Fold(cx, &pn->pn_kid, parser);
 
-      case ParseNodeKind::PNK_YIELD:
-      case ParseNodeKind::PNK_AWAIT:
+      case ParseNodeKind::Yield:
+      case ParseNodeKind::Await:
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (!pn->pn_kid)
             return true;
         return Fold(cx, &pn->pn_kid, parser);
 
-      case ParseNodeKind::PNK_RETURN:
+      case ParseNodeKind::Return:
         return FoldReturn(cx, pn, parser);
 
-      case ParseNodeKind::PNK_TRY:
+      case ParseNodeKind::Try:
         return FoldTry(cx, pn, parser);
 
-      case ParseNodeKind::PNK_CATCH:
+      case ParseNodeKind::Catch:
         return FoldCatch(cx, pn, parser);
 
-      case ParseNodeKind::PNK_CLASS:
+      case ParseNodeKind::Class:
         return FoldClass(cx, pn, parser);
 
-      case ParseNodeKind::PNK_ELEM:
+      case ParseNodeKind::Elem:
         return FoldElement(cx, pnp, parser);
 
-      case ParseNodeKind::PNK_ADD:
+      case ParseNodeKind::Add:
         return FoldAdd(cx, pnp, parser);
 
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_SUPERCALL:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::SuperCall:
+      case ParseNodeKind::TaggedTemplate:
         return FoldCall(cx, pn, parser);
 
-      case ParseNodeKind::PNK_SWITCH:
-      case ParseNodeKind::PNK_COLON:
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
-      case ParseNodeKind::PNK_IMPORT:
-      case ParseNodeKind::PNK_EXPORT_FROM:
-      case ParseNodeKind::PNK_SHORTHAND:
-      case ParseNodeKind::PNK_FOR:
-      case ParseNodeKind::PNK_CLASSMETHOD:
-      case ParseNodeKind::PNK_IMPORT_SPEC:
-      case ParseNodeKind::PNK_EXPORT_SPEC:
-      case ParseNodeKind::PNK_SETTHIS:
+      case ParseNodeKind::Switch:
+      case ParseNodeKind::Colon:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::PowAssign:
+      case ParseNodeKind::Import:
+      case ParseNodeKind::ExportFrom:
+      case ParseNodeKind::Shorthand:
+      case ParseNodeKind::For:
+      case ParseNodeKind::ClassMethod:
+      case ParseNodeKind::ImportSpec:
+      case ParseNodeKind::ExportSpec:
+      case ParseNodeKind::SetThis:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         return Fold(cx, &pn->pn_left, parser) &&
                Fold(cx, &pn->pn_right, parser);
 
-      case ParseNodeKind::PNK_NEWTARGET:
+      case ParseNodeKind::NewTarget:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
-        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PNK_POSHOLDER));
-        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_POSHOLDER));
+        MOZ_ASSERT(pn->pn_left->isKind(ParseNodeKind::PosHolder));
+        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PosHolder));
         return true;
 
-      case ParseNodeKind::PNK_CLASSNAMES:
+      case ParseNodeKind::ClassNames:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (ParseNode*& outerBinding = pn->pn_left) {
             if (!Fold(cx, &outerBinding, parser))
                 return false;
         }
         return Fold(cx, &pn->pn_right, parser);
 
-      case ParseNodeKind::PNK_DOWHILE:
+      case ParseNodeKind::DoWhile:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         return Fold(cx, &pn->pn_left, parser) &&
                FoldCondition(cx, &pn->pn_right, parser);
 
-      case ParseNodeKind::PNK_WHILE:
+      case ParseNodeKind::While:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         return FoldCondition(cx, &pn->pn_left, parser) &&
                Fold(cx, &pn->pn_right, parser);
 
-      case ParseNodeKind::PNK_CASE: {
+      case ParseNodeKind::Case: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
 
         // pn_left is null for DefaultClauses.
         if (pn->pn_left) {
             if (!Fold(cx, &pn->pn_left, parser))
                 return false;
         }
         return Fold(cx, &pn->pn_right, parser);
       }
 
-      case ParseNodeKind::PNK_WITH:
+      case ParseNodeKind::With:
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         return Fold(cx, &pn->pn_left, parser) &&
                Fold(cx, &pn->pn_right, parser);
 
-      case ParseNodeKind::PNK_FORIN:
-      case ParseNodeKind::PNK_FOROF:
+      case ParseNodeKind::ForIn:
+      case ParseNodeKind::ForOf:
         return FoldForInOrOf(cx, pn, parser);
 
-      case ParseNodeKind::PNK_FORHEAD:
+      case ParseNodeKind::ForHead:
         return FoldForHead(cx, pn, parser);
 
-      case ParseNodeKind::PNK_LABEL:
+      case ParseNodeKind::Label:
         MOZ_ASSERT(pn->isArity(PN_NAME));
         return Fold(cx, &pn->pn_expr, parser);
 
-      case ParseNodeKind::PNK_DOT:
+      case ParseNodeKind::Dot:
         return FoldDottedProperty(cx, pn, parser);
 
-      case ParseNodeKind::PNK_LEXICALSCOPE:
+      case ParseNodeKind::LexicalScope:
         MOZ_ASSERT(pn->isArity(PN_SCOPE));
         if (!pn->scopeBody())
             return true;
         return Fold(cx, &pn->pn_u.scope.body, parser);
 
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Name:
         return FoldName(cx, pn, parser);
 
-      case ParseNodeKind::PNK_LIMIT: // invalid sentinel value
+      case ParseNodeKind::Limit: // invalid sentinel value
         MOZ_CRASH("invalid node kind");
     }
 
     MOZ_CRASH("shouldn't reach here");
     return false;
 }
 
 template<typename CharT>
--- a/js/src/frontend/FullParseHandler.h
+++ b/js/src/frontend/FullParseHandler.h
@@ -52,36 +52,36 @@ class FullParseHandler
 
   public:
     /* new_ methods for creating parse nodes. These report OOM on context. */
     JS_DECLARE_NEW_METHODS(new_, allocParseNode, inline)
 
     typedef ParseNode* Node;
 
     bool isPropertyAccess(ParseNode* node) {
-        return node->isKind(ParseNodeKind::PNK_DOT) || node->isKind(ParseNodeKind::PNK_ELEM);
+        return node->isKind(ParseNodeKind::Dot) || node->isKind(ParseNodeKind::Elem);
     }
 
     bool isFunctionCall(ParseNode* node) {
         // Note: super() is a special form, *not* a function call.
-        return node->isKind(ParseNodeKind::PNK_CALL);
+        return node->isKind(ParseNodeKind::Call);
     }
 
     static bool isUnparenthesizedDestructuringPattern(ParseNode* node) {
-        return !node->isInParens() && (node->isKind(ParseNodeKind::PNK_OBJECT) ||
-                                       node->isKind(ParseNodeKind::PNK_ARRAY));
+        return !node->isInParens() && (node->isKind(ParseNodeKind::Object) ||
+                                       node->isKind(ParseNodeKind::Array));
     }
 
     static bool isParenthesizedDestructuringPattern(ParseNode* node) {
         // Technically this isn't a destructuring pattern at all -- the grammar
         // doesn't treat it as such.  But we need to know when this happens to
         // consider it a SyntaxError rather than an invalid-left-hand-side
         // ReferenceError.
-        return node->isInParens() && (node->isKind(ParseNodeKind::PNK_OBJECT) ||
-                                      node->isKind(ParseNodeKind::PNK_ARRAY));
+        return node->isInParens() && (node->isKind(ParseNodeKind::Object) ||
+                                      node->isKind(ParseNodeKind::Array));
     }
 
     FullParseHandler(JSContext* cx, LifoAlloc& alloc, LazyScript* lazyOuterFunction,
                      SourceKind kind = SourceKind::Text)
       : allocator(cx, alloc),
         lazyOuterFunction_(cx, lazyOuterFunction),
         lazyInnerFunctionIndex(0),
         lazyClosedOverBindingIndex(0),
@@ -97,46 +97,46 @@ class FullParseHandler
     // to determine whether we need to check these assumptions.
     SourceKind sourceKind() const { return sourceKind_; }
 
     ParseNode* freeTree(ParseNode* pn) { return allocator.freeTree(pn); }
     void prepareNodeForMutation(ParseNode* pn) { return allocator.prepareNodeForMutation(pn); }
 
     ParseNode* newName(PropertyName* name, const TokenPos& pos, JSContext* cx)
     {
-        return new_<NameNode>(ParseNodeKind::PNK_NAME, JSOP_GETNAME, name, pos);
+        return new_<NameNode>(ParseNodeKind::Name, JSOP_GETNAME, name, pos);
     }
 
     ParseNode* newComputedName(ParseNode* expr, uint32_t begin, uint32_t end) {
         TokenPos pos(begin, end);
-        return new_<UnaryNode>(ParseNodeKind::PNK_COMPUTED_NAME, pos, expr);
+        return new_<UnaryNode>(ParseNodeKind::ComputedName, pos, expr);
     }
 
     ParseNode* newObjectLiteralPropertyName(JSAtom* atom, const TokenPos& pos) {
-        return new_<NullaryNode>(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME, JSOP_NOP, pos, atom);
+        return new_<NullaryNode>(ParseNodeKind::ObjectPropertyName, JSOP_NOP, pos, atom);
     }
 
     ParseNode* newNumber(double value, DecimalPoint decimalPoint, const TokenPos& pos) {
-        ParseNode* pn = new_<NullaryNode>(ParseNodeKind::PNK_NUMBER, pos);
+        ParseNode* pn = new_<NullaryNode>(ParseNodeKind::Number, pos);
         if (!pn)
             return nullptr;
         pn->initNumber(value, decimalPoint);
         return pn;
     }
 
     ParseNode* newBooleanLiteral(bool cond, const TokenPos& pos) {
         return new_<BooleanLiteral>(cond, pos);
     }
 
     ParseNode* newStringLiteral(JSAtom* atom, const TokenPos& pos) {
-        return new_<NullaryNode>(ParseNodeKind::PNK_STRING, JSOP_NOP, pos, atom);
+        return new_<NullaryNode>(ParseNodeKind::String, JSOP_NOP, pos, atom);
     }
 
     ParseNode* newTemplateStringLiteral(JSAtom* atom, const TokenPos& pos) {
-        return new_<NullaryNode>(ParseNodeKind::PNK_TEMPLATE_STRING, JSOP_NOP, pos, atom);
+        return new_<NullaryNode>(ParseNodeKind::TemplateString, JSOP_NOP, pos, atom);
     }
 
     ParseNode* newCallSiteObject(uint32_t begin) {
         ParseNode* callSite = new_<CallSiteNode>(begin);
         if (!callSite)
             return null();
 
         Node propExpr = newArrayLiteral(callSite->pn_pos.begin);
@@ -144,17 +144,17 @@ class FullParseHandler
             return null();
 
         addArrayElement(callSite, propExpr);
 
         return callSite;
     }
 
     void addToCallSiteObject(ParseNode* callSiteObj, ParseNode* rawNode, ParseNode* cookedNode) {
-        MOZ_ASSERT(callSiteObj->isKind(ParseNodeKind::PNK_CALLSITEOBJ));
+        MOZ_ASSERT(callSiteObj->isKind(ParseNodeKind::CallSiteObj));
 
         addArrayElement(callSiteObj, cookedNode);
         addArrayElement(callSiteObj->pn_head, rawNode);
 
         /*
          * We don't know when the last noSubstTemplate will come in, and we
          * don't want to deal with this outside this method
          */
@@ -184,50 +184,50 @@ class FullParseHandler
         return new_<RegExpLiteral>(objbox, pos);
     }
 
     ParseNode* newConditional(ParseNode* cond, ParseNode* thenExpr, ParseNode* elseExpr) {
         return new_<ConditionalExpression>(cond, thenExpr, elseExpr);
     }
 
     ParseNode* newDelete(uint32_t begin, ParseNode* expr) {
-        if (expr->isKind(ParseNodeKind::PNK_NAME)) {
+        if (expr->isKind(ParseNodeKind::Name)) {
             expr->setOp(JSOP_DELNAME);
-            return newUnary(ParseNodeKind::PNK_DELETENAME, begin, expr);
+            return newUnary(ParseNodeKind::DeleteName, begin, expr);
         }
 
-        if (expr->isKind(ParseNodeKind::PNK_DOT))
-            return newUnary(ParseNodeKind::PNK_DELETEPROP, begin, expr);
+        if (expr->isKind(ParseNodeKind::Dot))
+            return newUnary(ParseNodeKind::DeleteProp, begin, expr);
 
-        if (expr->isKind(ParseNodeKind::PNK_ELEM))
-            return newUnary(ParseNodeKind::PNK_DELETEELEM, begin, expr);
+        if (expr->isKind(ParseNodeKind::Elem))
+            return newUnary(ParseNodeKind::DeleteElem, begin, expr);
 
-        return newUnary(ParseNodeKind::PNK_DELETEEXPR, begin, expr);
+        return newUnary(ParseNodeKind::DeleteExpr, begin, expr);
     }
 
     ParseNode* newTypeof(uint32_t begin, ParseNode* kid) {
-        ParseNodeKind pnk = kid->isKind(ParseNodeKind::PNK_NAME)
-                            ? ParseNodeKind::PNK_TYPEOFNAME
-                            : ParseNodeKind::PNK_TYPEOFEXPR;
+        ParseNodeKind pnk = kid->isKind(ParseNodeKind::Name)
+                            ? ParseNodeKind::TypeOfName
+                            : ParseNodeKind::TypeOfExpr;
         return newUnary(pnk, begin, kid);
     }
 
     ParseNode* newUnary(ParseNodeKind kind, uint32_t begin, ParseNode* kid) {
         TokenPos pos(begin, kid->pn_pos.end);
         return new_<UnaryNode>(kind, pos, kid);
     }
 
     ParseNode* newUpdate(ParseNodeKind kind, uint32_t begin, ParseNode* kid) {
         TokenPos pos(begin, kid->pn_pos.end);
         return new_<UnaryNode>(kind, pos, kid);
     }
 
     ParseNode* newSpread(uint32_t begin, ParseNode* kid) {
         TokenPos pos(begin, kid->pn_pos.end);
-        return new_<UnaryNode>(ParseNodeKind::PNK_SPREAD, pos, kid);
+        return new_<UnaryNode>(ParseNodeKind::Spread, pos, kid);
     }
 
   private:
     ParseNode* newBinary(ParseNodeKind kind, ParseNode* left, ParseNode* right,
                          JSOp op = JSOP_NOP)
     {
         TokenPos pos(left->pn_pos.begin, right->pn_pos.end);
         return new_<BinaryNode>(kind, op, pos, left, right);
@@ -238,33 +238,33 @@ class FullParseHandler
                                   ParseContext* pc)
     {
         return ParseNode::appendOrCreateList(kind, left, right, this, pc);
     }
 
     // Expressions
 
     ParseNode* newArrayLiteral(uint32_t begin) {
-        return new_<ListNode>(ParseNodeKind::PNK_ARRAY, TokenPos(begin, begin + 1));
+        return new_<ListNode>(ParseNodeKind::Array, TokenPos(begin, begin + 1));
     }
 
     MOZ_MUST_USE bool addElision(ParseNode* literal, const TokenPos& pos) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_ARRAY));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Array));
         MOZ_ASSERT(literal->isArity(PN_LIST));
 
-        ParseNode* elision = new_<NullaryNode>(ParseNodeKind::PNK_ELISION, pos);
+        ParseNode* elision = new_<NullaryNode>(ParseNodeKind::Elision, pos);
         if (!elision)
             return false;
         addList(/* list = */ literal, /* child = */ elision);
         literal->pn_xflags |= PNX_ARRAYHOLESPREAD | PNX_NONCONST;
         return true;
     }
 
     MOZ_MUST_USE bool addSpreadElement(ParseNode* literal, uint32_t begin, ParseNode* inner) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_ARRAY));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Array));
         MOZ_ASSERT(literal->isArity(PN_LIST));
 
         ParseNode* spread = newSpread(begin, inner);
         if (!spread)
             return false;
         addList(/* list = */ literal, /* child = */ spread);
         literal->pn_xflags |= PNX_ARRAYHOLESPREAD | PNX_NONCONST;
         return true;
@@ -274,98 +274,98 @@ class FullParseHandler
         MOZ_ASSERT(literal->isArity(PN_LIST));
 
         if (!element->isConstant())
             literal->pn_xflags |= PNX_NONCONST;
         addList(/* list = */ literal, /* child = */ element);
     }
 
     ParseNode* newCall(const TokenPos& pos) {
-        return new_<ListNode>(ParseNodeKind::PNK_CALL, JSOP_CALL, pos);
+        return new_<ListNode>(ParseNodeKind::Call, JSOP_CALL, pos);
     }
 
     ParseNode* newSuperCall(ParseNode* callee) {
-        return new_<ListNode>(ParseNodeKind::PNK_SUPERCALL, JSOP_SUPERCALL, callee);
+        return new_<ListNode>(ParseNodeKind::SuperCall, JSOP_SUPERCALL, callee);
     }
 
     ParseNode* newTaggedTemplate(const TokenPos& pos) {
-        return new_<ListNode>(ParseNodeKind::PNK_TAGGED_TEMPLATE, JSOP_CALL, pos);
+        return new_<ListNode>(ParseNodeKind::TaggedTemplate, JSOP_CALL, pos);
     }
 
     ParseNode* newObjectLiteral(uint32_t begin) {
-        return new_<ListNode>(ParseNodeKind::PNK_OBJECT, TokenPos(begin, begin + 1));
+        return new_<ListNode>(ParseNodeKind::Object, TokenPos(begin, begin + 1));
     }
 
     ParseNode* newClass(ParseNode* name, ParseNode* heritage, ParseNode* methodBlock,
                         const TokenPos& pos)
     {
         return new_<ClassNode>(name, heritage, methodBlock, pos);
     }
     ParseNode* newClassMethodList(uint32_t begin) {
-        return new_<ListNode>(ParseNodeKind::PNK_CLASSMETHODLIST, TokenPos(begin, begin + 1));
+        return new_<ListNode>(ParseNodeKind::ClassMethodList, TokenPos(begin, begin + 1));
     }
     ParseNode* newClassNames(ParseNode* outer, ParseNode* inner, const TokenPos& pos) {
         return new_<ClassNames>(outer, inner, pos);
     }
     ParseNode* newNewTarget(ParseNode* newHolder, ParseNode* targetHolder) {
-        return new_<BinaryNode>(ParseNodeKind::PNK_NEWTARGET, JSOP_NOP, newHolder, targetHolder);
+        return new_<BinaryNode>(ParseNodeKind::NewTarget, JSOP_NOP, newHolder, targetHolder);
     }
     ParseNode* newPosHolder(const TokenPos& pos) {
-        return new_<NullaryNode>(ParseNodeKind::PNK_POSHOLDER, pos);
+        return new_<NullaryNode>(ParseNodeKind::PosHolder, pos);
     }
     ParseNode* newSuperBase(ParseNode* thisName, const TokenPos& pos) {
-        return new_<UnaryNode>(ParseNodeKind::PNK_SUPERBASE, pos, thisName);
+        return new_<UnaryNode>(ParseNodeKind::SuperBase, pos, thisName);
     }
     ParseNode* newCatchBlock(ParseNode* catchName, ParseNode* catchGuard, ParseNode* catchBody) {
-        return new_<TernaryNode>(ParseNodeKind::PNK_CATCH, catchName, catchGuard, catchBody);
+        return new_<TernaryNode>(ParseNodeKind::Catch, catchName, catchGuard, catchBody);
     }
     MOZ_MUST_USE bool addPrototypeMutation(ParseNode* literal, uint32_t begin, ParseNode* expr) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Object));
         MOZ_ASSERT(literal->isArity(PN_LIST));
 
         // Object literals with mutated [[Prototype]] are non-constant so that
         // singleton objects will have Object.prototype as their [[Prototype]].
         setListFlag(literal, PNX_NONCONST);
 
-        ParseNode* mutation = newUnary(ParseNodeKind::PNK_MUTATEPROTO, begin, expr);
+        ParseNode* mutation = newUnary(ParseNodeKind::MutateProto, begin, expr);
         if (!mutation)
             return false;
         addList(/* list = */ literal, /* child = */ mutation);
         return true;
     }
 
     MOZ_MUST_USE bool addPropertyDefinition(ParseNode* literal, ParseNode* key, ParseNode* val) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Object));
         MOZ_ASSERT(literal->isArity(PN_LIST));
         MOZ_ASSERT(isUsableAsObjectPropertyName(key));
 
-        ParseNode* propdef = newBinary(ParseNodeKind::PNK_COLON, key, val, JSOP_INITPROP);
+        ParseNode* propdef = newBinary(ParseNodeKind::Colon, key, val, JSOP_INITPROP);
         if (!propdef)
             return false;
         addList(/* list = */ literal, /* child = */ propdef);
         return true;
     }
 
     MOZ_MUST_USE bool addShorthand(ParseNode* literal, ParseNode* name, ParseNode* expr) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Object));
         MOZ_ASSERT(literal->isArity(PN_LIST));
-        MOZ_ASSERT(name->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME));
-        MOZ_ASSERT(expr->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT(name->isKind(ParseNodeKind::ObjectPropertyName));
+        MOZ_ASSERT(expr->isKind(ParseNodeKind::Name));
         MOZ_ASSERT(name->pn_atom == expr->pn_atom);
 
         setListFlag(literal, PNX_NONCONST);
-        ParseNode* propdef = newBinary(ParseNodeKind::PNK_SHORTHAND, name, expr, JSOP_INITPROP);
+        ParseNode* propdef = newBinary(ParseNodeKind::Shorthand, name, expr, JSOP_INITPROP);
         if (!propdef)
             return false;
         addList(/* list = */ literal, /* child = */ propdef);
         return true;
     }
 
     MOZ_MUST_USE bool addSpreadProperty(ParseNode* literal, uint32_t begin, ParseNode* inner) {
-        MOZ_ASSERT(literal->isKind(ParseNodeKind::PNK_OBJECT));
+        MOZ_ASSERT(literal->isKind(ParseNodeKind::Object));
         MOZ_ASSERT(literal->isArity(PN_LIST));
 
         setListFlag(literal, PNX_NONCONST);
         ParseNode* spread = newSpread(begin, inner);
         if (!spread)
             return false;
         addList(/* list = */ literal, /* child = */ spread);
         return true;
@@ -383,262 +383,262 @@ class FullParseHandler
 
         addList(/* list = */ literal, /* child = */ propdef);
         return true;
     }
 
     MOZ_MUST_USE bool addClassMethodDefinition(ParseNode* methodList, ParseNode* key, ParseNode* fn,
                                                AccessorType atype, bool isStatic)
     {
-        MOZ_ASSERT(methodList->isKind(ParseNodeKind::PNK_CLASSMETHODLIST));
+        MOZ_ASSERT(methodList->isKind(ParseNodeKind::ClassMethodList));
         MOZ_ASSERT(isUsableAsObjectPropertyName(key));
 
         ParseNode* classMethod = new_<ClassMethod>(key, fn, AccessorTypeToJSOp(atype), isStatic);
         if (!classMethod)
             return false;
         addList(/* list = */ methodList, /* child = */ classMethod);
         return true;
     }
 
     ParseNode* newInitialYieldExpression(uint32_t begin, ParseNode* gen) {
         TokenPos pos(begin, begin + 1);
-        return new_<UnaryNode>(ParseNodeKind::PNK_INITIALYIELD, pos, gen);
+        return new_<UnaryNode>(ParseNodeKind::InitialYield, pos, gen);
     }
 
     ParseNode* newYieldExpression(uint32_t begin, ParseNode* value) {
         TokenPos pos(begin, value ? value->pn_pos.end : begin + 1);
-        return new_<UnaryNode>(ParseNodeKind::PNK_YIELD, pos, value);
+        return new_<UnaryNode>(ParseNodeKind::Yield, pos, value);
     }
 
     ParseNode* newYieldStarExpression(uint32_t begin, ParseNode* value) {
         TokenPos pos(begin, value->pn_pos.end);
-        return new_<UnaryNode>(ParseNodeKind::PNK_YIELD_STAR, pos, value);
+        return new_<UnaryNode>(ParseNodeKind::YieldStar, pos, value);
     }
 
     ParseNode* newAwaitExpression(uint32_t begin, ParseNode* value) {
         TokenPos pos(begin, value ? value->pn_pos.end : begin + 1);
-        return new_<UnaryNode>(ParseNodeKind::PNK_AWAIT, pos, value);
+        return new_<UnaryNode>(ParseNodeKind::Await, pos, value);
     }
 
     // Statements
 
     ParseNode* newStatementList(const TokenPos& pos) {
-        return new_<ListNode>(ParseNodeKind::PNK_STATEMENTLIST, pos);
+        return new_<ListNode>(ParseNodeKind::StatementList, pos);
     }
 
     MOZ_MUST_USE bool isFunctionStmt(ParseNode* stmt) {
-        while (stmt->isKind(ParseNodeKind::PNK_LABEL))
+        while (stmt->isKind(ParseNodeKind::Label))
             stmt = stmt->as<LabeledStatement>().statement();
-        return stmt->isKind(ParseNodeKind::PNK_FUNCTION);
+        return stmt->isKind(ParseNodeKind::Function);
     }
 
     void addStatementToList(ParseNode* list, ParseNode* stmt) {
-        MOZ_ASSERT(list->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+        MOZ_ASSERT(list->isKind(ParseNodeKind::StatementList));
 
         addList(/* list = */ list, /* child = */ stmt);
 
         if (isFunctionStmt(stmt)) {
             // PNX_FUNCDEFS notifies the emitter that the block contains
             // body-level function definitions that should be processed
             // before the rest of nodes.
             list->pn_xflags |= PNX_FUNCDEFS;
         }
     }
 
     void setListEndPosition(ParseNode* list, const TokenPos& pos) {
-        MOZ_ASSERT(list->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+        MOZ_ASSERT(list->isKind(ParseNodeKind::StatementList));
         list->pn_pos.end = pos.end;
     }
 
     void addCaseStatementToList(ParseNode* list, ParseNode* casepn) {
-        MOZ_ASSERT(list->isKind(ParseNodeKind::PNK_STATEMENTLIST));
-        MOZ_ASSERT(casepn->isKind(ParseNodeKind::PNK_CASE));
-        MOZ_ASSERT(casepn->pn_right->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+        MOZ_ASSERT(list->isKind(ParseNodeKind::StatementList));
+        MOZ_ASSERT(casepn->isKind(ParseNodeKind::Case));
+        MOZ_ASSERT(casepn->pn_right->isKind(ParseNodeKind::StatementList));
 
         addList(/* list = */ list, /* child = */ casepn);
 
         if (casepn->pn_right->pn_xflags & PNX_FUNCDEFS)
             list->pn_xflags |= PNX_FUNCDEFS;
     }
 
     MOZ_MUST_USE inline bool addCatchBlock(ParseNode* catchList, ParseNode* lexicalScope,
                               ParseNode* catchName, ParseNode* catchGuard,
                               ParseNode* catchBody);
 
     MOZ_MUST_USE bool prependInitialYield(ParseNode* stmtList, ParseNode* genName) {
-        MOZ_ASSERT(stmtList->isKind(ParseNodeKind::PNK_STATEMENTLIST));
+        MOZ_ASSERT(stmtList->isKind(ParseNodeKind::StatementList));
         MOZ_ASSERT(stmtList->isArity(PN_LIST));
 
         TokenPos yieldPos(stmtList->pn_pos.begin, stmtList->pn_pos.begin + 1);
-        ParseNode* makeGen = new_<NullaryNode>(ParseNodeKind::PNK_GENERATOR, yieldPos);
+        ParseNode* makeGen = new_<NullaryNode>(ParseNodeKind::Generator, yieldPos);
         if (!makeGen)
             return false;
 
         MOZ_ASSERT(genName->getOp() == JSOP_GETNAME);
         genName->setOp(JSOP_SETNAME);
-        ParseNode* genInit = newAssignment(ParseNodeKind::PNK_ASSIGN, /* lhs = */ genName,
+        ParseNode* genInit = newAssignment(ParseNodeKind::Assign, /* lhs = */ genName,
                                            /* rhs = */ makeGen);
         if (!genInit)
             return false;
 
         ParseNode* initialYield = newInitialYieldExpression(yieldPos.begin, genInit);
         if (!initialYield)
             return false;
 
         stmtList->prepend(initialYield);
         return true;
     }
 
     ParseNode* newSetThis(ParseNode* thisName, ParseNode* val) {
         MOZ_ASSERT(thisName->getOp() == JSOP_GETNAME);
         thisName->setOp(JSOP_SETNAME);
-        return newBinary(ParseNodeKind::PNK_SETTHIS, thisName, val);
+        return newBinary(ParseNodeKind::SetThis, thisName, val);
     }
 
     ParseNode* newEmptyStatement(const TokenPos& pos) {
-        return new_<UnaryNode>(ParseNodeKind::PNK_SEMI, pos, nullptr);
+        return new_<UnaryNode>(ParseNodeKind::Semi, pos, nullptr);
     }
 
     ParseNode* newImportDeclaration(ParseNode* importSpecSet,
                                     ParseNode* moduleSpec, const TokenPos& pos)
     {
-        ParseNode* pn = new_<BinaryNode>(ParseNodeKind::PNK_IMPORT, JSOP_NOP, pos,
+        ParseNode* pn = new_<BinaryNode>(ParseNodeKind::Import, JSOP_NOP, pos,
                                          importSpecSet, moduleSpec);
         if (!pn)
             return null();
         return pn;
     }
 
     ParseNode* newImportSpec(ParseNode* importNameNode, ParseNode* bindingName) {
-        return newBinary(ParseNodeKind::PNK_IMPORT_SPEC, importNameNode, bindingName);
+        return newBinary(ParseNodeKind::ImportSpec, importNameNode, bindingName);
     }
 
     ParseNode* newExportDeclaration(ParseNode* kid, const TokenPos& pos) {
-        return new_<UnaryNode>(ParseNodeKind::PNK_EXPORT, pos, kid);
+        return new_<UnaryNode>(ParseNodeKind::Export, pos, kid);
     }
 
     ParseNode* newExportFromDeclaration(uint32_t begin, ParseNode* exportSpecSet,
                                         ParseNode* moduleSpec)
     {
-        ParseNode* pn = new_<BinaryNode>(ParseNodeKind::PNK_EXPORT_FROM, JSOP_NOP, exportSpecSet,
+        ParseNode* pn = new_<BinaryNode>(ParseNodeKind::ExportFrom, JSOP_NOP, exportSpecSet,
                                          moduleSpec);
         if (!pn)
             return null();
         pn->pn_pos.begin = begin;
         return pn;
     }
 
     ParseNode* newExportDefaultDeclaration(ParseNode* kid, ParseNode* maybeBinding,
                                            const TokenPos& pos) {
-        return new_<BinaryNode>(ParseNodeKind::PNK_EXPORT_DEFAULT, JSOP_NOP, pos, kid, maybeBinding);
+        return new_<BinaryNode>(ParseNodeKind::ExportDefault, JSOP_NOP, pos, kid, maybeBinding);
     }
 
     ParseNode* newExportSpec(ParseNode* bindingName, ParseNode* exportName) {
-        return newBinary(ParseNodeKind::PNK_EXPORT_SPEC, bindingName, exportName);
+        return newBinary(ParseNodeKind::ExportSpec, bindingName, exportName);
     }
 
     ParseNode* newExportBatchSpec(const TokenPos& pos) {
-        return new_<NullaryNode>(ParseNodeKind::PNK_EXPORT_BATCH_SPEC, JSOP_NOP, pos);
+        return new_<NullaryNode>(ParseNodeKind::ExportBatchSpec, JSOP_NOP, pos);
     }
 
     ParseNode* newExprStatement(ParseNode* expr, uint32_t end) {
         MOZ_ASSERT(expr->pn_pos.end <= end);
-        return new_<UnaryNode>(ParseNodeKind::PNK_SEMI, TokenPos(expr->pn_pos.begin, end), expr);
+        return new_<UnaryNode>(ParseNodeKind::Semi, TokenPos(expr->pn_pos.begin, end), expr);
     }
 
     ParseNode* newIfStatement(uint32_t begin, ParseNode* cond, ParseNode* thenBranch,
                               ParseNode* elseBranch)
     {
-        ParseNode* pn = new_<TernaryNode>(ParseNodeKind::PNK_IF, cond, thenBranch, elseBranch);
+        ParseNode* pn = new_<TernaryNode>(ParseNodeKind::If, cond, thenBranch, elseBranch);
         if (!pn)
             return null();
         pn->pn_pos.begin = begin;
         return pn;
     }
 
     ParseNode* newDoWhileStatement(ParseNode* body, ParseNode* cond, const TokenPos& pos) {
-        return new_<BinaryNode>(ParseNodeKind::PNK_DOWHILE, JSOP_NOP, pos, body, cond);
+        return new_<BinaryNode>(ParseNodeKind::DoWhile, JSOP_NOP, pos, body, cond);
     }
 
     ParseNode* newWhileStatement(uint32_t begin, ParseNode* cond, ParseNode* body) {
         TokenPos pos(begin, body->pn_pos.end);
-        return new_<BinaryNode>(ParseNodeKind::PNK_WHILE, JSOP_NOP, pos, cond, body);
+        return new_<BinaryNode>(ParseNodeKind::While, JSOP_NOP, pos, cond, body);
     }
 
     ParseNode* newForStatement(uint32_t begin, ParseNode* forHead, ParseNode* body,
                                unsigned iflags)
     {
         /* A FOR node is binary, left is loop control and right is the body. */
-        JSOp op = forHead->isKind(ParseNodeKind::PNK_FORIN) ? JSOP_ITER : JSOP_NOP;
-        BinaryNode* pn = new_<BinaryNode>(ParseNodeKind::PNK_FOR, op,
+        JSOp op = forHead->isKind(ParseNodeKind::ForIn) ? JSOP_ITER : JSOP_NOP;
+        BinaryNode* pn = new_<BinaryNode>(ParseNodeKind::For, op,
                                           TokenPos(begin, body->pn_pos.end),
                                           forHead, body);
         if (!pn)
             return null();
         pn->pn_iflags = iflags;
         return pn;
     }
 
     ParseNode* newForHead(ParseNode* init, ParseNode* test, ParseNode* update,
                           const TokenPos& pos)
     {
-        return new_<TernaryNode>(ParseNodeKind::PNK_FORHEAD, init, test, update, pos);
+        return new_<TernaryNode>(ParseNodeKind::ForHead, init, test, update, pos);
     }
 
     ParseNode* newForInOrOfHead(ParseNodeKind kind, ParseNode* target, ParseNode* iteratedExpr,
                                 const TokenPos& pos)
     {
-        MOZ_ASSERT(kind == ParseNodeKind::PNK_FORIN || kind == ParseNodeKind::PNK_FOROF);
+        MOZ_ASSERT(kind == ParseNodeKind::ForIn || kind == ParseNodeKind::ForOf);
         return new_<TernaryNode>(kind, target, nullptr, iteratedExpr, pos);
     }
 
     ParseNode* newSwitchStatement(uint32_t begin, ParseNode* discriminant, ParseNode* caseList) {
         TokenPos pos(begin, caseList->pn_pos.end);
-        return new_<BinaryNode>(ParseNodeKind::PNK_SWITCH, JSOP_NOP, pos, discriminant, caseList);
+        return new_<BinaryNode>(ParseNodeKind::Switch, JSOP_NOP, pos, discriminant, caseList);
     }
 
     ParseNode* newCaseOrDefault(uint32_t begin, ParseNode* expr, ParseNode* body) {
         return new_<CaseClause>(expr, body, begin);
     }
 
     ParseNode* newContinueStatement(PropertyName* label, const TokenPos& pos) {
         return new_<ContinueStatement>(label, pos);
     }
 
     ParseNode* newBreakStatement(PropertyName* label, const TokenPos& pos) {
         return new_<BreakStatement>(label, pos);
     }
 
     ParseNode* newReturnStatement(ParseNode* expr, const TokenPos& pos) {
         MOZ_ASSERT_IF(expr, pos.encloses(expr->pn_pos));
-        return new_<UnaryNode>(ParseNodeKind::PNK_RETURN, pos, expr);
+        return new_<UnaryNode>(ParseNodeKind::Return, pos, expr);
     }
 
     ParseNode* newExpressionBody(ParseNode* expr) {
-        return new_<UnaryNode>(ParseNodeKind::PNK_RETURN, expr->pn_pos, expr);
+        return new_<UnaryNode>(ParseNodeKind::Return, expr->pn_pos, expr);
     }
 
     ParseNode* newWithStatement(uint32_t begin, ParseNode* expr, ParseNode* body) {
-        return new_<BinaryNode>(ParseNodeKind::PNK_WITH, JSOP_NOP, TokenPos(begin, body->pn_pos.end),
+        return new_<BinaryNode>(ParseNodeKind::With, JSOP_NOP, TokenPos(begin, body->pn_pos.end),
                                 expr, body);
     }
 
     ParseNode* newLabeledStatement(PropertyName* label, ParseNode* stmt, uint32_t begin) {
         return new_<LabeledStatement>(label, stmt, begin);
     }
 
     ParseNode* newThrowStatement(ParseNode* expr, const TokenPos& pos) {
         MOZ_ASSERT(pos.encloses(expr->pn_pos));
-        return new_<UnaryNode>(ParseNodeKind::PNK_THROW, pos, expr);
+        return new_<UnaryNode>(ParseNodeKind::Throw, pos, expr);
     }
 
     ParseNode* newTryStatement(uint32_t begin, ParseNode* body, ParseNode* catchScope,
                                ParseNode* finallyBlock) {
         TokenPos pos(begin, (finallyBlock ? finallyBlock : catchScope)->pn_pos.end);
-        return new_<TernaryNode>(ParseNodeKind::PNK_TRY, body, catchScope, finallyBlock, pos);
+        return new_<TernaryNode>(ParseNodeKind::Try, body, catchScope, finallyBlock, pos);
     }
 
     ParseNode* newDebuggerStatement(const TokenPos& pos) {
         return new_<DebuggerStatement>(pos);
     }
 
     ParseNode* newPropertyAccess(ParseNode* pn, PropertyName* name, uint32_t end) {
         return new_<PropertyAccess>(pn, name, pn->pn_pos.begin, end);
@@ -646,19 +646,19 @@ class FullParseHandler
 
     ParseNode* newPropertyByValue(ParseNode* lhs, ParseNode* index, uint32_t end) {
         return new_<PropertyByValue>(lhs, index, lhs->pn_pos.begin, end);
     }
 
     bool setupCatchScope(ParseNode* lexicalScope, ParseNode* catchName, ParseNode* catchBody) {
         ParseNode* catchpn;
         if (catchName) {
-            catchpn = new_<BinaryNode>(ParseNodeKind::PNK_CATCH, JSOP_NOP, catchName, catchBody);
+            catchpn = new_<BinaryNode>(ParseNodeKind::Catch, JSOP_NOP, catchName, catchBody);
         } else {
-            catchpn = new_<BinaryNode>(ParseNodeKind::PNK_CATCH, JSOP_NOP, catchBody->pn_pos,
+            catchpn = new_<BinaryNode>(ParseNodeKind::Catch, JSOP_NOP, catchBody->pn_pos,
                                        catchName, catchBody);
         }
         if (!catchpn)
             return false;
         lexicalScope->setScopeBody(catchpn);
         return true;
     }
 
@@ -666,134 +666,134 @@ class FullParseHandler
                                                                    ParseNode* pn);
 
     void checkAndSetIsDirectRHSAnonFunction(ParseNode* pn) {
         if (IsAnonymousFunctionDefinition(pn))
             pn->setDirectRHSAnonFunction(true);
     }
 
     ParseNode* newFunctionStatement(const TokenPos& pos) {
-        return new_<CodeNode>(ParseNodeKind::PNK_FUNCTION, JSOP_NOP, pos);
+        return new_<CodeNode>(ParseNodeKind::Function, JSOP_NOP, pos);
     }
 
     ParseNode* newFunctionExpression(const TokenPos& pos) {
-        return new_<CodeNode>(ParseNodeKind::PNK_FUNCTION, JSOP_LAMBDA, pos);
+        return new_<CodeNode>(ParseNodeKind::Function, JSOP_LAMBDA, pos);
     }
 
     ParseNode* newArrowFunction(const TokenPos& pos) {
-        return new_<CodeNode>(ParseNodeKind::PNK_FUNCTION, JSOP_LAMBDA_ARROW, pos);
+        return new_<CodeNode>(ParseNodeKind::Function, JSOP_LAMBDA_ARROW, pos);
     }
 
     bool isExpressionClosure(ParseNode* node) const {
-        return node->isKind(ParseNodeKind::PNK_FUNCTION) &&
+        return node->isKind(ParseNodeKind::Function) &&
                node->pn_funbox->isExprBody() &&
                !node->pn_funbox->isArrow();
     }
 
     ParseNode* newObjectMethodOrPropertyDefinition(ParseNode* key, ParseNode* fn, AccessorType atype) {
         MOZ_ASSERT(isUsableAsObjectPropertyName(key));
 
-        return newBinary(ParseNodeKind::PNK_COLON, key, fn, AccessorTypeToJSOp(atype));
+        return newBinary(ParseNodeKind::Colon, key, fn, AccessorTypeToJSOp(atype));
     }
 
     bool setComprehensionLambdaBody(ParseNode* pn, ParseNode* body) {
-        MOZ_ASSERT(body->isKind(ParseNodeKind::PNK_STATEMENTLIST));
-        ParseNode* paramsBody = newList(ParseNodeKind::PNK_PARAMSBODY, body);
+        MOZ_ASSERT(body->isKind(ParseNodeKind::StatementList));
+        ParseNode* paramsBody = newList(ParseNodeKind::ParamsBody, body);
         if (!paramsBody)
             return false;
         setFunctionFormalParametersAndBody(pn, paramsBody);
         return true;
     }
     void setFunctionFormalParametersAndBody(ParseNode* funcNode, ParseNode* kid) {
-        MOZ_ASSERT_IF(kid, kid->isKind(ParseNodeKind::PNK_PARAMSBODY));
+        MOZ_ASSERT_IF(kid, kid->isKind(ParseNodeKind::ParamsBody));
         funcNode->pn_body = kid;
     }
     void setFunctionBox(ParseNode* pn, FunctionBox* funbox) {
-        MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_FUNCTION));
+        MOZ_ASSERT(pn->isKind(ParseNodeKind::Function));
         pn->pn_funbox = funbox;
         funbox->functionNode = pn;
     }
     void addFunctionFormalParameter(ParseNode* pn, ParseNode* argpn) {
         addList(/* list = */ pn->pn_body, /* child = */ argpn);
     }
     void setFunctionBody(ParseNode* fn, ParseNode* body) {
-        MOZ_ASSERT(fn->pn_body->isKind(ParseNodeKind::PNK_PARAMSBODY));
+        MOZ_ASSERT(fn->pn_body->isKind(ParseNodeKind::ParamsBody));
         addList(/* list = */ fn->pn_body, /* child = */ body);
     }
 
     ParseNode* newModule(const TokenPos& pos) {
-        return new_<CodeNode>(ParseNodeKind::PNK_MODULE, JSOP_NOP, pos);
+        return new_<CodeNode>(ParseNodeKind::Module, JSOP_NOP, pos);
     }
 
     ParseNode* newLexicalScope(LexicalScope::Data* bindings, ParseNode* body) {
         return new_<LexicalScopeNode>(bindings, body);
     }
 
     Node newNewExpression(uint32_t begin, ParseNode* ctor) {
-        ParseNode* newExpr = new_<ListNode>(ParseNodeKind::PNK_NEW, JSOP_NEW, TokenPos(begin, begin + 1));
+        ParseNode* newExpr = new_<ListNode>(ParseNodeKind::New, JSOP_NEW, TokenPos(begin, begin + 1));
         if (!newExpr)
             return nullptr;
 
         addList(/* list = */ newExpr, /* child = */ ctor);
         return newExpr;
     }
 
     ParseNode* newAssignment(ParseNodeKind kind, ParseNode* lhs, ParseNode* rhs) {
         return newBinary(kind, lhs, rhs);
     }
 
     bool isUnparenthesizedAssignment(Node node) {
-        if (node->isKind(ParseNodeKind::PNK_ASSIGN) && !node->isInParens()) {
-            // ParseNodeKind::PNK_ASSIGN is also (mis)used for things like
+        if (node->isKind(ParseNodeKind::Assign) && !node->isInParens()) {
+            // ParseNodeKind::Assign is also (mis)used for things like
             // |var name = expr;|. But this method is only called on actual
             // expressions, so we can just assert the node's op is the one used
             // for plain assignment.
             MOZ_ASSERT(node->isOp(JSOP_NOP));
             return true;
         }
 
         return false;
     }
 
     bool isUnparenthesizedUnaryExpression(ParseNode* node) {
         if (!node->isInParens()) {
             ParseNodeKind kind = node->getKind();
-            return kind == ParseNodeKind::PNK_VOID ||
-                   kind == ParseNodeKind::PNK_NOT ||
-                   kind == ParseNodeKind::PNK_BITNOT ||
-                   kind == ParseNodeKind::PNK_POS ||
-                   kind == ParseNodeKind::PNK_NEG ||
+            return kind == ParseNodeKind::Void ||
+                   kind == ParseNodeKind::Not ||
+                   kind == ParseNodeKind::BitNot ||
+                   kind == ParseNodeKind::Pos ||
+                   kind == ParseNodeKind::Neg ||
                    IsTypeofKind(kind) ||
                    IsDeleteKind(kind);
         }
         return false;
     }
 
     bool isReturnStatement(ParseNode* node) {
-        return node->isKind(ParseNodeKind::PNK_RETURN);
+        return node->isKind(ParseNodeKind::Return);
     }
 
     bool isStatementPermittedAfterReturnStatement(ParseNode *node) {
         ParseNodeKind kind = node->getKind();
-        return kind == ParseNodeKind::PNK_FUNCTION ||
-               kind == ParseNodeKind::PNK_VAR ||
-               kind == ParseNodeKind::PNK_BREAK ||
-               kind == ParseNodeKind::PNK_THROW ||
-               (kind == ParseNodeKind::PNK_SEMI && !node->pn_kid);
+        return kind == ParseNodeKind::Function ||
+               kind == ParseNodeKind::Var ||
+               kind == ParseNodeKind::Break ||
+               kind == ParseNodeKind::Throw ||
+               (kind == ParseNodeKind::Semi && !node->pn_kid);
     }
 
     bool isSuperBase(ParseNode* node) {
-        return node->isKind(ParseNodeKind::PNK_SUPERBASE);
+        return node->isKind(ParseNodeKind::SuperBase);
     }
 
     bool isUsableAsObjectPropertyName(ParseNode* node) {
-        return node->isKind(ParseNodeKind::PNK_NUMBER)
-            || node->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME)
-            || node->isKind(ParseNodeKind::PNK_STRING)
-            || node->isKind(ParseNodeKind::PNK_COMPUTED_NAME);
+        return node->isKind(ParseNodeKind::Number)
+            || node->isKind(ParseNodeKind::ObjectPropertyName)
+            || node->isKind(ParseNodeKind::String)
+            || node->isKind(ParseNodeKind::ComputedName);
     }
 
     inline MOZ_MUST_USE bool finishInitializerAssignment(ParseNode* pn, ParseNode* init);
 
     void setBeginPosition(ParseNode* pn, ParseNode* oth) {
         setBeginPosition(pn, oth->pn_pos.begin);
     }
     void setBeginPosition(ParseNode* pn, uint32_t begin) {
@@ -809,19 +809,19 @@ class FullParseHandler
         MOZ_ASSERT(pn->pn_pos.begin <= pn->pn_pos.end);
     }
 
     uint32_t getFunctionNameOffset(ParseNode* func, TokenStreamAnyChars& ts) {
         return func->pn_pos.begin;
     }
 
     bool isDeclarationKind(ParseNodeKind kind) {
-        return kind == ParseNodeKind::PNK_VAR ||
-               kind == ParseNodeKind::PNK_LET ||
-               kind == ParseNodeKind::PNK_CONST;
+        return kind == ParseNodeKind::Var ||
+               kind == ParseNodeKind::Let ||
+               kind == ParseNodeKind::Const;
     }
 
     ParseNode* newList(ParseNodeKind kind, const TokenPos& pos) {
         MOZ_ASSERT(!isDeclarationKind(kind));
         return new_<ListNode>(kind, JSOP_NOP, pos);
     }
 
   private:
@@ -845,17 +845,17 @@ class FullParseHandler
 
     ParseNode* singleBindingFromDeclaration(ParseNode* decl) {
         MOZ_ASSERT(isDeclarationList(decl));
         MOZ_ASSERT(decl->pn_count == 1);
         return decl->pn_head;
     }
 
     ParseNode* newCommaExpressionList(ParseNode* kid) {
-        return new_<ListNode>(ParseNodeKind::PNK_COMMA, JSOP_NOP, kid);
+        return new_<ListNode>(ParseNodeKind::Comma, JSOP_NOP, kid);
     }
 
     void addList(ParseNode* list, ParseNode* kid) {
         if (sourceKind_ == SourceKind::Text)
             list->append(kid);
         else
             list->appendWithoutOrderAssumption(kid);
     }
@@ -878,29 +878,29 @@ class FullParseHandler
         pn->pn_prologue = true;
     }
 
     bool isConstant(ParseNode* pn) {
         return pn->isConstant();
     }
 
     bool isName(ParseNode* node) {
-        return node->isKind(ParseNodeKind::PNK_NAME);
+        return node->isKind(ParseNodeKind::Name);
     }
 
     bool isArgumentsName(ParseNode* node, JSContext* cx) {
-        return node->isKind(ParseNodeKind::PNK_NAME) && node->pn_atom == cx->names().arguments;
+        return node->isKind(ParseNodeKind::Name) && node->pn_atom == cx->names().arguments;
     }
 
     bool isEvalName(ParseNode* node, JSContext* cx) {
-        return node->isKind(ParseNodeKind::PNK_NAME) && node->pn_atom == cx->names().eval;
+        return node->isKind(ParseNodeKind::Name) && node->pn_atom == cx->names().eval;
     }
 
     bool isAsyncKeyword(ParseNode* node, JSContext* cx) {
-        return node->isKind(ParseNodeKind::PNK_NAME) &&
+        return node->isKind(ParseNodeKind::Name) &&
                node->pn_pos.begin + strlen("async") == node->pn_pos.end &&
                node->pn_atom == cx->names().async;
     }
 
     PropertyName* maybeDottedProperty(ParseNode* pn) {
         return pn->is<PropertyAccess>() ? &pn->as<PropertyAccess>().name() : nullptr;
     }
     JSAtom* isStringExprStatement(ParseNode* pn, TokenPos* pos) {
@@ -943,21 +943,21 @@ FullParseHandler::addCatchBlock(ParseNod
     lexicalScope->setScopeBody(catchpn);
     return true;
 }
 
 inline bool
 FullParseHandler::setLastFunctionFormalParameterDefault(ParseNode* funcpn,
                                                         ParseNode* defaultValue)
 {
-    MOZ_ASSERT(funcpn->isKind(ParseNodeKind::PNK_FUNCTION));
+    MOZ_ASSERT(funcpn->isKind(ParseNodeKind::Function));
     MOZ_ASSERT(funcpn->isArity(PN_CODE));
 
     ParseNode* arg = funcpn->pn_body->last();
-    ParseNode* pn = newBinary(ParseNodeKind::PNK_ASSIGN, arg, defaultValue);
+    ParseNode* pn = newBinary(ParseNodeKind::Assign, arg, defaultValue);
     if (!pn)
         return false;
 
     checkAndSetIsDirectRHSAnonFunction(defaultValue);
 
     funcpn->pn_body->pn_pos.end = pn->pn_pos.end;
     ParseNode* pnchild = funcpn->pn_body->pn_head;
     ParseNode* pnlast = funcpn->pn_body->last();
--- a/js/src/frontend/NameFunctions.cpp
+++ b/js/src/frontend/NameFunctions.cpp
@@ -29,28 +29,28 @@ class NameResolver
     JSContext* cx;
     size_t nparents;                /* number of parents in the parents array */
     MOZ_INIT_OUTSIDE_CTOR
     ParseNode* parents[MaxParents]; /* history of ParseNodes we've been looking at */
     StringBuffer* buf;              /* when resolving, buffer to append to */
 
     /* Test whether a ParseNode represents a function invocation */
     bool call(ParseNode* pn) {
-        return pn && pn->isKind(ParseNodeKind::PNK_CALL);
+        return pn && pn->isKind(ParseNodeKind::Call);
     }
 
     /*
      * Append a reference to a property named |name| to |buf|. If |name| is
      * a proper identifier name, then we append '.name'; otherwise, we
      * append '["name"]'.
      *
      * Note that we need the IsIdentifier check for atoms from both
-     * ParseNodeKind::PNK_NAME nodes and ParseNodeKind::PNK_STRING nodes:
-     * given code like a["b c"], the front end will produce a ParseNodeKind::PNK_DOT
-     * with a ParseNodeKind::PNK_NAME child whose name contains spaces.
+     * ParseNodeKind::Name nodes and ParseNodeKind::String nodes:
+     * given code like a["b c"], the front end will produce a ParseNodeKind::Dot
+     * with a ParseNodeKind::Name child whose name contains spaces.
      */
     bool appendPropertyReference(JSAtom* name) {
         if (IsIdentifier(name))
             return buf->append('.') && buf->append(name);
 
         /* Quote the string as needed. */
         JSString* source = QuoteString(cx, name, '"');
         return source && buf->append('[') && buf->append(source) && buf->append(']');
@@ -71,43 +71,43 @@ class NameResolver
     /*
      * Walk over the given ParseNode, attempting to convert it to a stringified
      * name that respresents where the function is being assigned to.
      *
      * |*foundName| is set to true if a name is found for the expression.
      */
     bool nameExpression(ParseNode* n, bool* foundName) {
         switch (n->getKind()) {
-          case ParseNodeKind::PNK_DOT:
+          case ParseNodeKind::Dot:
             if (!nameExpression(n->expr(), foundName))
                 return false;
             if (!*foundName)
                 return true;
             return appendPropertyReference(n->pn_atom);
 
-          case ParseNodeKind::PNK_NAME:
+          case ParseNodeKind::Name:
             *foundName = true;
             return buf->append(n->pn_atom);
 
-          case ParseNodeKind::PNK_THIS:
+          case ParseNodeKind::This:
             *foundName = true;
             return buf->append("this");
 
-          case ParseNodeKind::PNK_ELEM:
+          case ParseNodeKind::Elem:
             if (!nameExpression(n->pn_left, foundName))
                 return false;
             if (!*foundName)
                 return true;
             if (!buf->append('[') || !nameExpression(n->pn_right, foundName))
                 return false;
             if (!*foundName)
                 return true;
             return buf->append(']');
 
-          case ParseNodeKind::PNK_NUMBER:
+          case ParseNodeKind::Number:
             *foundName = true;
             return appendNumber(n->pn_dval);
 
           default:
             /* We're confused as to what to call this function. */
             *foundName = false;
             return true;
         }
@@ -130,50 +130,50 @@ class NameResolver
         *size = 0;
 
         for (int pos = nparents - 1; pos >= 0; pos--) {
             ParseNode* cur = parents[pos];
             if (cur->isAssignment())
                 return cur;
 
             switch (cur->getKind()) {
-              case ParseNodeKind::PNK_NAME:     return cur;  /* found the initialized declaration */
-              case ParseNodeKind::PNK_THIS:     return cur;  /* Setting a property of 'this'. */
-              case ParseNodeKind::PNK_FUNCTION: return nullptr; /* won't find an assignment or declaration */
+              case ParseNodeKind::Name:     return cur;  /* found the initialized declaration */
+              case ParseNodeKind::This:     return cur;  /* Setting a property of 'this'. */
+              case ParseNodeKind::Function: return nullptr; /* won't find an assignment or declaration */
 
-              case ParseNodeKind::PNK_RETURN:
+              case ParseNodeKind::Return:
                 /*
                  * Normally the relevant parent of a node is its direct parent, but
                  * sometimes with code like:
                  *
                  *    var foo = (function() { return function() {}; })();
                  *
                  * the outer function is just a helper to create a scope for the
                  * returned function. Hence the name of the returned function should
                  * actually be 'foo'.  This loop sees if the current node is a
-                 * ParseNodeKind::PNK_RETURN, and if there is a direct function
+                 * ParseNodeKind::Return, and if there is a direct function
                  * call we skip to that.
                  */
                 for (int tmp = pos - 1; tmp > 0; tmp--) {
                     if (isDirectCall(tmp, cur)) {
                         pos = tmp;
                         break;
                     } else if (call(cur)) {
                         /* Don't skip too high in the tree */
                         break;
                     }
                     cur = parents[tmp];
                 }
                 break;
 
-              case ParseNodeKind::PNK_COLON:
-              case ParseNodeKind::PNK_SHORTHAND:
+              case ParseNodeKind::Colon:
+              case ParseNodeKind::Shorthand:
                 /*
-                 * Record the ParseNodeKind::PNK_COLON/SHORTHAND but skip the
-                 * ParseNodeKind::PNK_OBJECT so we're not flagged as a
+                 * Record the ParseNodeKind::Colon/SHORTHAND but skip the
+                 * ParseNodeKind::Object so we're not flagged as a
                  * contributor.
                  */
                 pos--;
                 MOZ_FALLTHROUGH;
 
               default:
                 /* Save any other nodes we encounter on the way up. */
                 MOZ_ASSERT(*size < MaxParents);
@@ -187,17 +187,17 @@ class NameResolver
 
     /*
      * Resolve the name of a function. If the function already has a name
      * listed, then it is skipped. Otherwise an intelligent name is guessed to
      * assign to the function's displayAtom field.
      */
     bool resolveFun(ParseNode* pn, HandleAtom prefix, MutableHandleAtom retAtom) {
         MOZ_ASSERT(pn != nullptr);
-        MOZ_ASSERT(pn->isKind(ParseNodeKind::PNK_FUNCTION));
+        MOZ_ASSERT(pn->isKind(ParseNodeKind::Function));
         MOZ_ASSERT(pn->isArity(PN_CODE));
         RootedFunction fun(cx, pn->pn_funbox->function());
 
         StringBuffer buf(cx);
         this->buf = &buf;
 
         retAtom.set(nullptr);
 
@@ -238,28 +238,28 @@ class NameResolver
         /*
          * Other than the actual assignment, other relevant nodes to naming are
          * those in object initializers and then particular nodes marking a
          * contribution.
          */
         for (int pos = size - 1; pos >= 0; pos--) {
             ParseNode* node = toName[pos];
 
-            if (node->isKind(ParseNodeKind::PNK_COLON) || node->isKind(ParseNodeKind::PNK_SHORTHAND)) {
+            if (node->isKind(ParseNodeKind::Colon) || node->isKind(ParseNodeKind::Shorthand)) {
                 ParseNode* left = node->pn_left;
-                if (left->isKind(ParseNodeKind::PNK_OBJECT_PROPERTY_NAME) ||
-                    left->isKind(ParseNodeKind::PNK_STRING))
+                if (left->isKind(ParseNodeKind::ObjectPropertyName) ||
+                    left->isKind(ParseNodeKind::String))
                 {
                     if (!appendPropertyReference(left->pn_atom))
                         return false;
-                } else if (left->isKind(ParseNodeKind::PNK_NUMBER)) {
+                } else if (left->isKind(ParseNodeKind::Number)) {
                     if (!appendNumericPropertyReference(left->pn_dval))
                         return false;
                 } else {
-                    MOZ_ASSERT(left->isKind(ParseNodeKind::PNK_COMPUTED_NAME));
+                    MOZ_ASSERT(left->isKind(ParseNodeKind::ComputedName));
                 }
             } else {
                 /*
                  * Don't have consecutive '<' characters, and also don't start
                  * with a '<' character.
                  */
                 if (!buf.empty() && buf.getChar(buf.length() - 1) != '<' && !buf.append('<'))
                     return false;
@@ -289,56 +289,56 @@ class NameResolver
      * This is the case for functions which do things like simply create a scope
      * for new variables and then return an anonymous function using this scope.
      */
     bool isDirectCall(int pos, ParseNode* cur) {
         return pos >= 0 && call(parents[pos]) && parents[pos]->pn_head == cur;
     }
 
     bool resolveTemplateLiteral(ParseNode* node, HandleAtom prefix) {
-        MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_TEMPLATE_STRING_LIST));
+        MOZ_ASSERT(node->isKind(ParseNodeKind::TemplateStringList));
         ParseNode* element = node->pn_head;
         while (true) {
-            MOZ_ASSERT(element->isKind(ParseNodeKind::PNK_TEMPLATE_STRING));
+            MOZ_ASSERT(element->isKind(ParseNodeKind::TemplateString));
 
             element = element->pn_next;
             if (!element)
                 return true;
 
             if (!resolve(element, prefix))
                 return false;
 
             element = element->pn_next;
         }
     }
 
     bool resolveTaggedTemplate(ParseNode* node, HandleAtom prefix) {
-        MOZ_ASSERT(node->isKind(ParseNodeKind::PNK_TAGGED_TEMPLATE));
+        MOZ_ASSERT(node->isKind(ParseNodeKind::TaggedTemplate));
 
         ParseNode* element = node->pn_head;
 
         // The list head is a leading expression, e.g. |tag| in |tag`foo`|,
         // that might contain functions.
         if (!resolve(element, prefix))
             return false;
 
         // Next is the callsite object node.  This node only contains
         // internal strings or undefined and an array -- no user-controlled
         // expressions.
         element = element->pn_next;
 #ifdef DEBUG
         {
-            MOZ_ASSERT(element->isKind(ParseNodeKind::PNK_CALLSITEOBJ));
+            MOZ_ASSERT(element->isKind(ParseNodeKind::CallSiteObj));
             ParseNode* array = element->pn_head;
-            MOZ_ASSERT(array->isKind(ParseNodeKind::PNK_ARRAY));
+            MOZ_ASSERT(array->isKind(ParseNodeKind::Array));
             for (ParseNode* kid = array->pn_head; kid; kid = kid->pn_next)
-                MOZ_ASSERT(kid->isKind(ParseNodeKind::PNK_TEMPLATE_STRING));
+                MOZ_ASSERT(kid->isKind(ParseNodeKind::TemplateString));
             for (ParseNode* next = array->pn_next; next; next = next->pn_next) {
-                MOZ_ASSERT(next->isKind(ParseNodeKind::PNK_TEMPLATE_STRING) ||
-                           next->isKind(ParseNodeKind::PNK_RAW_UNDEFINED));
+                MOZ_ASSERT(next->isKind(ParseNodeKind::TemplateString) ||
+                           next->isKind(ParseNodeKind::RawUndefined));
             }
         }
 #endif
 
         // Next come any interpolated expressions in the tagged template.
         ParseNode* interpolated = element->pn_next;
         for (; interpolated; interpolated = interpolated->pn_next) {
             if (!resolve(interpolated, prefix))
@@ -356,19 +356,19 @@ class NameResolver
      * ParseNode instance given. The prefix is for each subsequent name, and
      * should initially be nullptr.
      */
     bool resolve(ParseNode* const cur, HandleAtom prefixArg = nullptr) {
         RootedAtom prefix(cx, prefixArg);
         if (cur == nullptr)
             return true;
 
-        MOZ_ASSERT(cur->isArity(PN_CODE) == (cur->isKind(ParseNodeKind::PNK_FUNCTION) ||
-                                             cur->isKind(ParseNodeKind::PNK_MODULE)));
-        if (cur->isKind(ParseNodeKind::PNK_FUNCTION)) {
+        MOZ_ASSERT(cur->isArity(PN_CODE) == (cur->isKind(ParseNodeKind::Function) ||
+                                             cur->isKind(ParseNodeKind::Module)));
+        if (cur->isKind(ParseNodeKind::Function)) {
             RootedAtom prefix2(cx);
             if (!resolveFun(cur, prefix, &prefix2))
                 return false;
 
             /*
              * If a function looks like (function(){})() where the parent node
              * of the definition of the function is a call, then it shouldn't
              * contribute anything to the namespace, so don't bother updating
@@ -383,214 +383,214 @@ class NameResolver
 
         auto initialParents = nparents;
         parents[initialParents] = cur;
         nparents++;
 
         switch (cur->getKind()) {
           // Nodes with no children that might require name resolution need no
           // further work.
-          case ParseNodeKind::PNK_NOP:
-          case ParseNodeKind::PNK_STRING:
-          case ParseNodeKind::PNK_TEMPLATE_STRING:
-          case ParseNodeKind::PNK_REGEXP:
-          case ParseNodeKind::PNK_TRUE:
-          case ParseNodeKind::PNK_FALSE:
-          case ParseNodeKind::PNK_NULL:
-          case ParseNodeKind::PNK_RAW_UNDEFINED:
-          case ParseNodeKind::PNK_ELISION:
-          case ParseNodeKind::PNK_GENERATOR:
-          case ParseNodeKind::PNK_NUMBER:
-          case ParseNodeKind::PNK_BREAK:
-          case ParseNodeKind::PNK_CONTINUE:
-          case ParseNodeKind::PNK_DEBUGGER:
-          case ParseNodeKind::PNK_EXPORT_BATCH_SPEC:
-          case ParseNodeKind::PNK_OBJECT_PROPERTY_NAME:
-          case ParseNodeKind::PNK_POSHOLDER:
+          case ParseNodeKind::Nop:
+          case ParseNodeKind::String:
+          case ParseNodeKind::TemplateString:
+          case ParseNodeKind::RegExp:
+          case ParseNodeKind::True:
+          case ParseNodeKind::False:
+          case ParseNodeKind::Null:
+          case ParseNodeKind::RawUndefined:
+          case ParseNodeKind::Elision:
+          case ParseNodeKind::Generator:
+          case ParseNodeKind::Number:
+          case ParseNodeKind::Break:
+          case ParseNodeKind::Continue:
+          case ParseNodeKind::Debugger:
+          case ParseNodeKind::ExportBatchSpec:
+          case ParseNodeKind::ObjectPropertyName:
+          case ParseNodeKind::PosHolder:
             MOZ_ASSERT(cur->isArity(PN_NULLARY));
             break;
 
-          case ParseNodeKind::PNK_TYPEOFNAME:
-          case ParseNodeKind::PNK_SUPERBASE:
+          case ParseNodeKind::TypeOfName:
+          case ParseNodeKind::SuperBase:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
-            MOZ_ASSERT(cur->pn_kid->isKind(ParseNodeKind::PNK_NAME));
+            MOZ_ASSERT(cur->pn_kid->isKind(ParseNodeKind::Name));
             MOZ_ASSERT(!cur->pn_kid->expr());
             break;
 
-          case ParseNodeKind::PNK_NEWTARGET:
+          case ParseNodeKind::NewTarget:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
-            MOZ_ASSERT(cur->pn_left->isKind(ParseNodeKind::PNK_POSHOLDER));
-            MOZ_ASSERT(cur->pn_right->isKind(ParseNodeKind::PNK_POSHOLDER));
+            MOZ_ASSERT(cur->pn_left->isKind(ParseNodeKind::PosHolder));
+            MOZ_ASSERT(cur->pn_right->isKind(ParseNodeKind::PosHolder));
             break;
 
           // Nodes with a single non-null child requiring name resolution.
-          case ParseNodeKind::PNK_TYPEOFEXPR:
-          case ParseNodeKind::PNK_VOID:
-          case ParseNodeKind::PNK_NOT:
-          case ParseNodeKind::PNK_BITNOT:
-          case ParseNodeKind::PNK_THROW:
-          case ParseNodeKind::PNK_DELETENAME:
-          case ParseNodeKind::PNK_DELETEPROP:
-          case ParseNodeKind::PNK_DELETEELEM:
-          case ParseNodeKind::PNK_DELETEEXPR:
-          case ParseNodeKind::PNK_NEG:
-          case ParseNodeKind::PNK_POS:
-          case ParseNodeKind::PNK_PREINCREMENT:
-          case ParseNodeKind::PNK_POSTINCREMENT:
-          case ParseNodeKind::PNK_PREDECREMENT:
-          case ParseNodeKind::PNK_POSTDECREMENT:
-          case ParseNodeKind::PNK_COMPUTED_NAME:
-          case ParseNodeKind::PNK_SPREAD:
-          case ParseNodeKind::PNK_MUTATEPROTO:
-          case ParseNodeKind::PNK_EXPORT:
+          case ParseNodeKind::TypeOfExpr:
+          case ParseNodeKind::Void:
+          case ParseNodeKind::Not:
+          case ParseNodeKind::BitNot:
+          case ParseNodeKind::Throw:
+          case ParseNodeKind::DeleteName:
+          case ParseNodeKind::DeleteProp:
+          case ParseNodeKind::DeleteElem:
+          case ParseNodeKind::DeleteExpr:
+          case ParseNodeKind::Neg:
+          case ParseNodeKind::Pos:
+          case ParseNodeKind::PreIncrement:
+          case ParseNodeKind::PostIncrement:
+          case ParseNodeKind::PreDecrement:
+          case ParseNodeKind::PostDecrement:
+          case ParseNodeKind::ComputedName:
+          case ParseNodeKind::Spread:
+          case ParseNodeKind::MutateProto:
+          case ParseNodeKind::Export:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
             if (!resolve(cur->pn_kid, prefix))
                 return false;
             break;
 
           // Nodes with a single nullable child.
-          case ParseNodeKind::PNK_SEMI:
-          case ParseNodeKind::PNK_THIS:
+          case ParseNodeKind::Semi:
+          case ParseNodeKind::This:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
             if (ParseNode* expr = cur->pn_kid) {
                 if (!resolve(expr, prefix))
                     return false;
             }
             break;
 
           // Binary nodes with two non-null children.
-          case ParseNodeKind::PNK_ASSIGN:
-          case ParseNodeKind::PNK_ADDASSIGN:
-          case ParseNodeKind::PNK_SUBASSIGN:
-          case ParseNodeKind::PNK_BITORASSIGN:
-          case ParseNodeKind::PNK_BITXORASSIGN:
-          case ParseNodeKind::PNK_BITANDASSIGN:
-          case ParseNodeKind::PNK_LSHASSIGN:
-          case ParseNodeKind::PNK_RSHASSIGN:
-          case ParseNodeKind::PNK_URSHASSIGN:
-          case ParseNodeKind::PNK_MULASSIGN:
-          case ParseNodeKind::PNK_DIVASSIGN:
-          case ParseNodeKind::PNK_MODASSIGN:
-          case ParseNodeKind::PNK_POWASSIGN:
-          case ParseNodeKind::PNK_COLON:
-          case ParseNodeKind::PNK_SHORTHAND:
-          case ParseNodeKind::PNK_DOWHILE:
-          case ParseNodeKind::PNK_WHILE:
-          case ParseNodeKind::PNK_SWITCH:
-          case ParseNodeKind::PNK_FOR:
-          case ParseNodeKind::PNK_CLASSMETHOD:
-          case ParseNodeKind::PNK_SETTHIS:
+          case ParseNodeKind::Assign:
+          case ParseNodeKind::AddAssign:
+          case ParseNodeKind::SubAssign:
+          case ParseNodeKind::BitOrAssign:
+          case ParseNodeKind::BitXorAssign:
+          case ParseNodeKind::BitAndAssign:
+          case ParseNodeKind::LshAssign:
+          case ParseNodeKind::RshAssign:
+          case ParseNodeKind::UrshAssign:
+          case ParseNodeKind::MulAssign:
+          case ParseNodeKind::DivAssign:
+          case ParseNodeKind::ModAssign:
+          case ParseNodeKind::PowAssign:
+          case ParseNodeKind::Colon:
+          case ParseNodeKind::Shorthand:
+          case ParseNodeKind::DoWhile:
+          case ParseNodeKind::While:
+          case ParseNodeKind::Switch:
+          case ParseNodeKind::For:
+          case ParseNodeKind::ClassMethod:
+          case ParseNodeKind::SetThis:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             if (!resolve(cur->pn_left, prefix))
                 return false;
             if (!resolve(cur->pn_right, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_ELEM:
+          case ParseNodeKind::Elem:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             if (!cur->as<PropertyByValue>().isSuper() && !resolve(cur->pn_left, prefix))
                 return false;
             if (!resolve(cur->pn_right, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_WITH:
+          case ParseNodeKind::With:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             if (!resolve(cur->pn_left, prefix))
                 return false;
             if (!resolve(cur->pn_right, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_CASE:
+          case ParseNodeKind::Case:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             if (ParseNode* caseExpr = cur->pn_left) {
                 if (!resolve(caseExpr, prefix))
                     return false;
             }
             if (!resolve(cur->pn_right, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_INITIALYIELD:
-            MOZ_ASSERT(cur->pn_kid->isKind(ParseNodeKind::PNK_ASSIGN) &&
-                       cur->pn_kid->pn_left->isKind(ParseNodeKind::PNK_NAME) &&
-                       cur->pn_kid->pn_right->isKind(ParseNodeKind::PNK_GENERATOR));
+          case ParseNodeKind::InitialYield:
+            MOZ_ASSERT(cur->pn_kid->isKind(ParseNodeKind::Assign) &&
+                       cur->pn_kid->pn_left->isKind(ParseNodeKind::Name) &&
+                       cur->pn_kid->pn_right->isKind(ParseNodeKind::Generator));
             break;
 
-          case ParseNodeKind::PNK_YIELD_STAR:
+          case ParseNodeKind::YieldStar:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
             if (!resolve(cur->pn_kid, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_YIELD:
-          case ParseNodeKind::PNK_AWAIT:
+          case ParseNodeKind::Yield:
+          case ParseNodeKind::Await:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
             if (cur->pn_kid) {
                 if (!resolve(cur->pn_kid, prefix))
                     return false;
             }
             break;
 
-          case ParseNodeKind::PNK_RETURN:
+          case ParseNodeKind::Return:
             MOZ_ASSERT(cur->isArity(PN_UNARY));
             if (ParseNode* returnValue = cur->pn_kid) {
                 if (!resolve(returnValue, prefix))
                     return false;
             }
             break;
 
-          case ParseNodeKind::PNK_IMPORT:
-          case ParseNodeKind::PNK_EXPORT_FROM:
-          case ParseNodeKind::PNK_EXPORT_DEFAULT:
+          case ParseNodeKind::Import:
+          case ParseNodeKind::ExportFrom:
+          case ParseNodeKind::ExportDefault:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             // The left halves of these nodes don't contain any unconstrained
             // expressions, but it's very hard to assert this to safely rely on
             // it.  So recur anyway.
             if (!resolve(cur->pn_left, prefix))
                 return false;
-            MOZ_ASSERT_IF(!cur->isKind(ParseNodeKind::PNK_EXPORT_DEFAULT),
-                          cur->pn_right->isKind(ParseNodeKind::PNK_STRING));
+            MOZ_ASSERT_IF(!cur->isKind(ParseNodeKind::ExportDefault),
+                          cur->pn_right->isKind(ParseNodeKind::String));
             break;
 
           // Ternary nodes with three expression children.
-          case ParseNodeKind::PNK_CONDITIONAL:
+          case ParseNodeKind::Conditional:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
             if (!resolve(cur->pn_kid1, prefix))
                 return false;
             if (!resolve(cur->pn_kid2, prefix))
                 return false;
             if (!resolve(cur->pn_kid3, prefix))
                 return false;
             break;
 
           // The first part of a for-in/of is the declaration in the loop (or
           // null if no declaration).  The latter two parts are the location
           // assigned each loop and the value being looped over; obviously,
           // either might contain functions to name.  Declarations may (through
           // computed property names, and possibly through [deprecated!]
           // initializers) also contain functions to name.
-          case ParseNodeKind::PNK_FORIN:
-          case ParseNodeKind::PNK_FOROF:
+          case ParseNodeKind::ForIn:
+          case ParseNodeKind::ForOf:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
             if (ParseNode* decl = cur->pn_kid1) {
                 if (!resolve(decl, prefix))
                     return false;
             }
             if (!resolve(cur->pn_kid2, prefix))
                 return false;
             if (!resolve(cur->pn_kid3, prefix))
                 return false;
             break;
 
           // Every part of a for(;;) head may contain a function needing name
           // resolution.
-          case ParseNodeKind::PNK_FORHEAD:
+          case ParseNodeKind::ForHead:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
             if (ParseNode* init = cur->pn_kid1) {
                 if (!resolve(init, prefix))
                     return false;
             }
             if (ParseNode* cond = cur->pn_kid2) {
                 if (!resolve(cond, prefix))
                     return false;
@@ -599,222 +599,222 @@ class NameResolver
                 if (!resolve(step, prefix))
                     return false;
             }
             break;
 
           // The first child of a class is a pair of names referring to it,
           // inside and outside the class.  The second is the class's heritage,
           // if any.  The third is the class body.
-          case ParseNodeKind::PNK_CLASS:
+          case ParseNodeKind::Class:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
-            MOZ_ASSERT_IF(cur->pn_kid1, cur->pn_kid1->isKind(ParseNodeKind::PNK_CLASSNAMES));
+            MOZ_ASSERT_IF(cur->pn_kid1, cur->pn_kid1->isKind(ParseNodeKind::ClassNames));
             MOZ_ASSERT_IF(cur->pn_kid1, cur->pn_kid1->isArity(PN_BINARY));
             MOZ_ASSERT_IF(cur->pn_kid1 && cur->pn_kid1->pn_left,
-                          cur->pn_kid1->pn_left->isKind(ParseNodeKind::PNK_NAME));
+                          cur->pn_kid1->pn_left->isKind(ParseNodeKind::Name));
             MOZ_ASSERT_IF(cur->pn_kid1 && cur->pn_kid1->pn_left,
                           !cur->pn_kid1->pn_left->expr());
-            MOZ_ASSERT_IF(cur->pn_kid1, cur->pn_kid1->pn_right->isKind(ParseNodeKind::PNK_NAME));
+            MOZ_ASSERT_IF(cur->pn_kid1, cur->pn_kid1->pn_right->isKind(ParseNodeKind::Name));
             MOZ_ASSERT_IF(cur->pn_kid1, !cur->pn_kid1->pn_right->expr());
             if (cur->pn_kid2) {
                 if (!resolve(cur->pn_kid2, prefix))
                     return false;
             }
             if (!resolve(cur->pn_kid3, prefix))
                 return false;
             break;
 
           // The condition and consequent are non-optional, but the alternative
           // might be omitted.
-          case ParseNodeKind::PNK_IF:
+          case ParseNodeKind::If:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
             if (!resolve(cur->pn_kid1, prefix))
                 return false;
             if (!resolve(cur->pn_kid2, prefix))
                 return false;
             if (cur->pn_kid3) {
                 if (!resolve(cur->pn_kid3, prefix))
                     return false;
             }
             break;
 
           // The statements in the try-block are mandatory.  The catch-blocks
           // and finally block are optional (but at least one or the other must
           // be present).
-          case ParseNodeKind::PNK_TRY:
+          case ParseNodeKind::Try:
             MOZ_ASSERT(cur->isArity(PN_TERNARY));
             if (!resolve(cur->pn_kid1, prefix))
                 return false;
             MOZ_ASSERT(cur->pn_kid2 || cur->pn_kid3);
             if (ParseNode* catchScope = cur->pn_kid2) {
-                MOZ_ASSERT(catchScope->isKind(ParseNodeKind::PNK_LEXICALSCOPE));
-                MOZ_ASSERT(catchScope->scopeBody()->isKind(ParseNodeKind::PNK_CATCH));
+                MOZ_ASSERT(catchScope->isKind(ParseNodeKind::LexicalScope));
+                MOZ_ASSERT(catchScope->scopeBody()->isKind(ParseNodeKind::Catch));
                 MOZ_ASSERT(catchScope->scopeBody()->isArity(PN_BINARY));
                 if (!resolve(catchScope->scopeBody(), prefix))
                     return false;
             }
             if (ParseNode* finallyBlock = cur->pn_kid3) {
                 if (!resolve(finallyBlock, prefix))
                     return false;
             }
             break;
 
           // The first child, the catch-pattern, may contain functions via
           // computed property names.  The optional catch-conditions may
           // contain any expression.  The catch statements, of course, may
           // contain arbitrary expressions.
-          case ParseNodeKind::PNK_CATCH:
+          case ParseNodeKind::Catch:
             MOZ_ASSERT(cur->isArity(PN_BINARY));
             if (cur->pn_left) {
               if (!resolve(cur->pn_left, prefix))
                   return false;
             }
             if (!resolve(cur->pn_right, prefix))
                 return false;
             break;
 
           // Nodes with arbitrary-expression children.
-          case ParseNodeKind::PNK_OR:
-          case ParseNodeKind::PNK_AND:
-          case ParseNodeKind::PNK_BITOR:
-          case ParseNodeKind::PNK_BITXOR:
-          case ParseNodeKind::PNK_BITAND:
-          case ParseNodeKind::PNK_STRICTEQ:
-          case ParseNodeKind::PNK_EQ:
-          case ParseNodeKind::PNK_STRICTNE:
-          case ParseNodeKind::PNK_NE:
-          case ParseNodeKind::PNK_LT:
-          case ParseNodeKind::PNK_LE:
-          case ParseNodeKind::PNK_GT:
-          case ParseNodeKind::PNK_GE:
-          case ParseNodeKind::PNK_INSTANCEOF:
-          case ParseNodeKind::PNK_IN:
-          case ParseNodeKind::PNK_LSH:
-          case ParseNodeKind::PNK_RSH:
-          case ParseNodeKind::PNK_URSH:
-          case ParseNodeKind::PNK_ADD:
-          case ParseNodeKind::PNK_SUB:
-          case ParseNodeKind::PNK_STAR:
-          case ParseNodeKind::PNK_DIV:
-          case ParseNodeKind::PNK_MOD:
-          case ParseNodeKind::PNK_POW:
-          case ParseNodeKind::PNK_PIPELINE:
-          case ParseNodeKind::PNK_COMMA:
-          case ParseNodeKind::PNK_NEW:
-          case ParseNodeKind::PNK_CALL:
-          case ParseNodeKind::PNK_SUPERCALL:
-          case ParseNodeKind::PNK_ARRAY:
-          case ParseNodeKind::PNK_STATEMENTLIST:
-          case ParseNodeKind::PNK_PARAMSBODY:
+          case ParseNodeKind::Or:
+          case ParseNodeKind::And:
+          case ParseNodeKind::BitOr:
+          case ParseNodeKind::BitXor:
+          case ParseNodeKind::BitAnd:
+          case ParseNodeKind::StrictEq:
+          case ParseNodeKind::Eq:
+          case ParseNodeKind::StrictNe:
+          case ParseNodeKind::Ne:
+          case ParseNodeKind::Lt:
+          case ParseNodeKind::Le:
+          case ParseNodeKind::Gt:
+          case ParseNodeKind::Ge:
+          case ParseNodeKind::InstanceOf:
+          case ParseNodeKind::In:
+          case ParseNodeKind::Lsh:
+          case ParseNodeKind::Rsh:
+          case ParseNodeKind::Ursh:
+          case ParseNodeKind::Add:
+          case ParseNodeKind::Sub:
+          case ParseNodeKind::Star:
+          case ParseNodeKind::Div:
+          case ParseNodeKind::Mod:
+          case ParseNodeKind::Pow:
+          case ParseNodeKind::Pipeline:
+          case ParseNodeKind::Comma:
+          case ParseNodeKind::New:
+          case ParseNodeKind::Call:
+          case ParseNodeKind::SuperCall:
+          case ParseNodeKind::Array:
+          case ParseNodeKind::StatementList:
+          case ParseNodeKind::ParamsBody:
           // Initializers for individual variables, and computed property names
           // within destructuring patterns, may contain unnamed functions.
-          case ParseNodeKind::PNK_VAR:
-          case ParseNodeKind::PNK_CONST:
-          case ParseNodeKind::PNK_LET:
+          case ParseNodeKind::Var:
+          case ParseNodeKind::Const:
+          case ParseNodeKind::Let:
             MOZ_ASSERT(cur->isArity(PN_LIST));
             for (ParseNode* element = cur->pn_head; element; element = element->pn_next) {
                 if (!resolve(element, prefix))
                     return false;
             }
             break;
 
-          case ParseNodeKind::PNK_OBJECT:
-          case ParseNodeKind::PNK_CLASSMETHODLIST:
+          case ParseNodeKind::Object:
+          case ParseNodeKind::ClassMethodList:
             MOZ_ASSERT(cur->isArity(PN_LIST));
             for (ParseNode* element = cur->pn_head; element; element = element->pn_next) {
                 if (!resolve(element, prefix))
                     return false;
             }
             break;
 
           // A template string list's contents alternate raw template string
           // contents with expressions interpolated into the overall literal.
-          case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
+          case ParseNodeKind::TemplateStringList:
             MOZ_ASSERT(cur->isArity(PN_LIST));
             if (!resolveTemplateLiteral(cur, prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_TAGGED_TEMPLATE:
+          case ParseNodeKind::TaggedTemplate:
             MOZ_ASSERT(cur->isArity(PN_LIST));
             if (!resolveTaggedTemplate(cur, prefix))
                 return false;
             break;
 
           // Import/export spec lists contain import/export specs containing
           // only pairs of names. Alternatively, an export spec lists may
           // contain a single export batch specifier.
-          case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
-          case ParseNodeKind::PNK_IMPORT_SPEC_LIST: {
+          case ParseNodeKind::ExportSpecList:
+          case ParseNodeKind::ImportSpecList: {
             MOZ_ASSERT(cur->isArity(PN_LIST));
 #ifdef DEBUG
-            bool isImport = cur->isKind(ParseNodeKind::PNK_IMPORT_SPEC_LIST);
+            bool isImport = cur->isKind(ParseNodeKind::ImportSpecList);
             ParseNode* item = cur->pn_head;
-            if (!isImport && item && item->isKind(ParseNodeKind::PNK_EXPORT_BATCH_SPEC)) {
+            if (!isImport && item && item->isKind(ParseNodeKind::ExportBatchSpec)) {
                 MOZ_ASSERT(item->isArity(PN_NULLARY));
                 break;
             }
             for (; item; item = item->pn_next) {
                 MOZ_ASSERT(item->isKind(isImport
-                                        ? ParseNodeKind::PNK_IMPORT_SPEC
-                                        : ParseNodeKind::PNK_EXPORT_SPEC));
+                                        ? ParseNodeKind::ImportSpec
+                                        : ParseNodeKind::ExportSpec));
                 MOZ_ASSERT(item->isArity(PN_BINARY));
-                MOZ_ASSERT(item->pn_left->isKind(ParseNodeKind::PNK_NAME));
+                MOZ_ASSERT(item->pn_left->isKind(ParseNodeKind::Name));
                 MOZ_ASSERT(!item->pn_left->expr());
-                MOZ_ASSERT(item->pn_right->isKind(ParseNodeKind::PNK_NAME));
+                MOZ_ASSERT(item->pn_right->isKind(ParseNodeKind::Name));
                 MOZ_ASSERT(!item->pn_right->expr());
             }
 #endif
             break;
           }
 
-          case ParseNodeKind::PNK_DOT:
+          case ParseNodeKind::Dot:
             MOZ_ASSERT(cur->isArity(PN_NAME));
 
             // Super prop nodes do not have a meaningful LHS
             if (cur->as<PropertyAccess>().isSuper())
                 break;
             if (!resolve(cur->expr(), prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_LABEL:
+          case ParseNodeKind::Label:
             MOZ_ASSERT(cur->isArity(PN_NAME));
             if (!resolve(cur->expr(), prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_NAME:
+          case ParseNodeKind::Name:
             MOZ_ASSERT(cur->isArity(PN_NAME));
             if (!resolve(cur->expr(), prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_LEXICALSCOPE:
+          case ParseNodeKind::LexicalScope:
             MOZ_ASSERT(cur->isArity(PN_SCOPE));
             if (!resolve(cur->scopeBody(), prefix))
                 return false;
             break;
 
-          case ParseNodeKind::PNK_FUNCTION:
-          case ParseNodeKind::PNK_MODULE:
+          case ParseNodeKind::Function:
+          case ParseNodeKind::Module:
             MOZ_ASSERT(cur->isArity(PN_CODE));
             if (!resolve(cur->pn_body, prefix))
                 return false;
             break;
 
           // Kinds that should be handled by parent node resolution.
 
-          case ParseNodeKind::PNK_IMPORT_SPEC: // by ParseNodeKind::PNK_IMPORT_SPEC_LIST
-          case ParseNodeKind::PNK_EXPORT_SPEC: // by ParseNodeKind::PNK_EXPORT_SPEC_LIST
-          case ParseNodeKind::PNK_CALLSITEOBJ: // by ParseNodeKind::PNK_TAGGED_TEMPLATE
-          case ParseNodeKind::PNK_CLASSNAMES:  // by ParseNodeKind::PNK_CLASS
+          case ParseNodeKind::ImportSpec: // by ParseNodeKind::ImportSpecList
+          case ParseNodeKind::ExportSpec: // by ParseNodeKind::ExportSpecList
+          case ParseNodeKind::CallSiteObj: // by ParseNodeKind::TaggedTemplate
+          case ParseNodeKind::ClassNames:  // by ParseNodeKind::Class
             MOZ_CRASH("should have been handled by a parent node");
 
-          case ParseNodeKind::PNK_LIMIT: // invalid sentinel value
+          case ParseNodeKind::Limit: // invalid sentinel value
             MOZ_CRASH("invalid node kind");
         }
 
         nparents--;
         MOZ_ASSERT(initialParents == nparents, "nparents imbalance detected");
 
         // It would be nice to common up the repeated |parents[initialParents]|
         // in a single variable, but the #if condition required to prevent an
--- a/js/src/frontend/ParseNode-inl.h
+++ b/js/src/frontend/ParseNode-inl.h
@@ -12,24 +12,24 @@
 #include "frontend/SharedContext.h"
 
 namespace js {
 namespace frontend {
 
 inline PropertyName*
 ParseNode::name() const
 {
-    MOZ_ASSERT(isKind(ParseNodeKind::PNK_FUNCTION) || isKind(ParseNodeKind::PNK_NAME));
-    JSAtom* atom = isKind(ParseNodeKind::PNK_FUNCTION) ? pn_funbox->function()->explicitName() : pn_atom;
+    MOZ_ASSERT(isKind(ParseNodeKind::Function) || isKind(ParseNodeKind::Name));
+    JSAtom* atom = isKind(ParseNodeKind::Function) ? pn_funbox->function()->explicitName() : pn_atom;
     return atom->asPropertyName();
 }
 
 inline JSAtom*
 ParseNode::atom() const
 {
-    MOZ_ASSERT(isKind(ParseNodeKind::PNK_STRING));
+    MOZ_ASSERT(isKind(ParseNodeKind::String));
     return pn_atom;
 }
 
 } /* namespace frontend */
 } /* namespace js */
 
 #endif /* frontend_ParseNode_inl_h */
--- a/js/src/frontend/ParseNode.cpp
+++ b/js/src/frontend/ParseNode.cpp
@@ -178,310 +178,310 @@ PushUnaryNodeChild(ParseNode* node, Node
  * just need to take care of its children.
  */
 static PushResult
 PushNodeChildren(ParseNode* pn, NodeStack* stack)
 {
     switch (pn->getKind()) {
       // Trivial nodes that refer to no nodes, are referred to by nothing
       // but their parents, are never used, and are never a definition.
-      case ParseNodeKind::PNK_NOP:
-      case ParseNodeKind::PNK_STRING:
-      case ParseNodeKind::PNK_TEMPLATE_STRING:
-      case ParseNodeKind::PNK_REGEXP:
-      case ParseNodeKind::PNK_TRUE:
-      case ParseNodeKind::PNK_FALSE:
-      case ParseNodeKind::PNK_NULL:
-      case ParseNodeKind::PNK_RAW_UNDEFINED:
-      case ParseNodeKind::PNK_ELISION:
-      case ParseNodeKind::PNK_GENERATOR:
-      case ParseNodeKind::PNK_NUMBER:
-      case ParseNodeKind::PNK_BREAK:
-      case ParseNodeKind::PNK_CONTINUE:
-      case ParseNodeKind::PNK_DEBUGGER:
-      case ParseNodeKind::PNK_EXPORT_BATCH_SPEC:
-      case ParseNodeKind::PNK_OBJECT_PROPERTY_NAME:
-      case ParseNodeKind::PNK_POSHOLDER:
+      case ParseNodeKind::Nop:
+      case ParseNodeKind::String:
+      case ParseNodeKind::TemplateString:
+      case ParseNodeKind::RegExp:
+      case ParseNodeKind::True:
+      case ParseNodeKind::False:
+      case ParseNodeKind::Null:
+      case ParseNodeKind::RawUndefined:
+      case ParseNodeKind::Elision:
+      case ParseNodeKind::Generator:
+      case ParseNodeKind::Number:
+      case ParseNodeKind::Break:
+      case ParseNodeKind::Continue:
+      case ParseNodeKind::Debugger:
+      case ParseNodeKind::ExportBatchSpec:
+      case ParseNodeKind::ObjectPropertyName:
+      case ParseNodeKind::PosHolder:
         MOZ_ASSERT(pn->isArity(PN_NULLARY));
         return PushResult::Recyclable;
 
       // Nodes with a single non-null child.
-      case ParseNodeKind::PNK_TYPEOFNAME:
-      case ParseNodeKind::PNK_TYPEOFEXPR:
-      case ParseNodeKind::PNK_VOID:
-      case ParseNodeKind::PNK_NOT:
-      case ParseNodeKind::PNK_BITNOT:
-      case ParseNodeKind::PNK_THROW:
-      case ParseNodeKind::PNK_DELETENAME:
-      case ParseNodeKind::PNK_DELETEPROP:
-      case ParseNodeKind::PNK_DELETEELEM:
-      case ParseNodeKind::PNK_DELETEEXPR:
-      case ParseNodeKind::PNK_POS:
-      case ParseNodeKind::PNK_NEG:
-      case ParseNodeKind::PNK_PREINCREMENT:
-      case ParseNodeKind::PNK_POSTINCREMENT:
-      case ParseNodeKind::PNK_PREDECREMENT:
-      case ParseNodeKind::PNK_POSTDECREMENT:
-      case ParseNodeKind::PNK_COMPUTED_NAME:
-      case ParseNodeKind::PNK_SPREAD:
-      case ParseNodeKind::PNK_MUTATEPROTO:
-      case ParseNodeKind::PNK_EXPORT:
-      case ParseNodeKind::PNK_SUPERBASE:
+      case ParseNodeKind::TypeOfName:
+      case ParseNodeKind::TypeOfExpr:
+      case ParseNodeKind::Void:
+      case ParseNodeKind::Not:
+      case ParseNodeKind::BitNot:
+      case ParseNodeKind::Throw:
+      case ParseNodeKind::DeleteName:
+      case ParseNodeKind::DeleteProp:
+      case ParseNodeKind::DeleteElem:
+      case ParseNodeKind::DeleteExpr:
+      case ParseNodeKind::Pos:
+      case ParseNodeKind::Neg:
+      case ParseNodeKind::PreIncrement:
+      case ParseNodeKind::PostIncrement:
+      case ParseNodeKind::PreDecrement:
+      case ParseNodeKind::PostDecrement:
+      case ParseNodeKind::ComputedName:
+      case ParseNodeKind::Spread:
+      case ParseNodeKind::MutateProto:
+      case ParseNodeKind::Export:
+      case ParseNodeKind::SuperBase:
         return PushUnaryNodeChild(pn, stack);
 
       // Nodes with a single nullable child.
-      case ParseNodeKind::PNK_THIS:
-      case ParseNodeKind::PNK_SEMI: {
+      case ParseNodeKind::This:
+      case ParseNodeKind::Semi: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (pn->pn_kid)
             stack->push(pn->pn_kid);
         return PushResult::Recyclable;
       }
 
       // Binary nodes with two non-null children.
 
       // All assignment and compound assignment nodes qualify.
-      case ParseNodeKind::PNK_ASSIGN:
-      case ParseNodeKind::PNK_ADDASSIGN:
-      case ParseNodeKind::PNK_SUBASSIGN:
-      case ParseNodeKind::PNK_BITORASSIGN:
-      case ParseNodeKind::PNK_BITXORASSIGN:
-      case ParseNodeKind::PNK_BITANDASSIGN:
-      case ParseNodeKind::PNK_LSHASSIGN:
-      case ParseNodeKind::PNK_RSHASSIGN:
-      case ParseNodeKind::PNK_URSHASSIGN:
-      case ParseNodeKind::PNK_MULASSIGN:
-      case ParseNodeKind::PNK_DIVASSIGN:
-      case ParseNodeKind::PNK_MODASSIGN:
-      case ParseNodeKind::PNK_POWASSIGN:
+      case ParseNodeKind::Assign:
+      case ParseNodeKind::AddAssign:
+      case ParseNodeKind::SubAssign:
+      case ParseNodeKind::BitOrAssign:
+      case ParseNodeKind::BitXorAssign:
+      case ParseNodeKind::BitAndAssign:
+      case ParseNodeKind::LshAssign:
+      case ParseNodeKind::RshAssign:
+      case ParseNodeKind::UrshAssign:
+      case ParseNodeKind::MulAssign:
+      case ParseNodeKind::DivAssign:
+      case ParseNodeKind::ModAssign:
+      case ParseNodeKind::PowAssign:
       // ...and a few others.
-      case ParseNodeKind::PNK_ELEM:
-      case ParseNodeKind::PNK_IMPORT_SPEC:
-      case ParseNodeKind::PNK_EXPORT_SPEC:
-      case ParseNodeKind::PNK_COLON:
-      case ParseNodeKind::PNK_SHORTHAND:
-      case ParseNodeKind::PNK_DOWHILE:
-      case ParseNodeKind::PNK_WHILE:
-      case ParseNodeKind::PNK_SWITCH:
-      case ParseNodeKind::PNK_CLASSMETHOD:
-      case ParseNodeKind::PNK_NEWTARGET:
-      case ParseNodeKind::PNK_SETTHIS:
-      case ParseNodeKind::PNK_FOR:
-      case ParseNodeKind::PNK_WITH: {
+      case ParseNodeKind::Elem:
+      case ParseNodeKind::ImportSpec:
+      case ParseNodeKind::ExportSpec:
+      case ParseNodeKind::Colon:
+      case ParseNodeKind::Shorthand:
+      case ParseNodeKind::DoWhile:
+      case ParseNodeKind::While:
+      case ParseNodeKind::Switch:
+      case ParseNodeKind::ClassMethod:
+      case ParseNodeKind::NewTarget:
+      case ParseNodeKind::SetThis:
+      case ParseNodeKind::For:
+      case ParseNodeKind::With: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         stack->push(pn->pn_left);
         stack->push(pn->pn_right);
         return PushResult::Recyclable;
       }
 
-      // Default clauses are ParseNodeKind::PNK_CASE but do not have case
+      // Default clauses are ParseNodeKind::Case but do not have case
       // expressions. Named class expressions do not have outer binding nodes.
       // So both are binary nodes with a possibly-null pn_left.
-      case ParseNodeKind::PNK_CASE:
-      case ParseNodeKind::PNK_CLASSNAMES: {
+      case ParseNodeKind::Case:
+      case ParseNodeKind::ClassNames: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (pn->pn_left)
             stack->push(pn->pn_left);
         stack->push(pn->pn_right);
         return PushResult::Recyclable;
       }
 
-      // The child is an assignment of a ParseNodeKind::PNK_GENERATOR node to the
+      // The child is an assignment of a ParseNodeKind::Generator node to the
       // '.generator' local, for a synthesized, prepended initial yield.
-      case ParseNodeKind::PNK_INITIALYIELD: {
+      case ParseNodeKind::InitialYield: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
-        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::PNK_ASSIGN) &&
-                   pn->pn_kid->pn_left->isKind(ParseNodeKind::PNK_NAME) &&
-                   pn->pn_kid->pn_right->isKind(ParseNodeKind::PNK_GENERATOR));
+        MOZ_ASSERT(pn->pn_kid->isKind(ParseNodeKind::Assign) &&
+                   pn->pn_kid->pn_left->isKind(ParseNodeKind::Name) &&
+                   pn->pn_kid->pn_right->isKind(ParseNodeKind::Generator));
         stack->push(pn->pn_kid);
         return PushResult::Recyclable;
       }
 
       // The child is the expression being yielded.
-      case ParseNodeKind::PNK_YIELD_STAR:
-      case ParseNodeKind::PNK_YIELD:
-      case ParseNodeKind::PNK_AWAIT: {
+      case ParseNodeKind::YieldStar:
+      case ParseNodeKind::Yield:
+      case ParseNodeKind::Await: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (pn->pn_kid)
             stack->push(pn->pn_kid);
         return PushResult::Recyclable;
       }
 
       // A return node's child is what you'd expect: the return expression,
       // if any.
-      case ParseNodeKind::PNK_RETURN: {
+      case ParseNodeKind::Return: {
         MOZ_ASSERT(pn->isArity(PN_UNARY));
         if (pn->pn_kid)
             stack->push(pn->pn_kid);
         return PushResult::Recyclable;
       }
 
       // Import and export-from nodes have a list of specifiers on the left
       // and a module string on the right.
-      case ParseNodeKind::PNK_IMPORT:
-      case ParseNodeKind::PNK_EXPORT_FROM: {
+      case ParseNodeKind::Import:
+      case ParseNodeKind::ExportFrom: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
-        MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::PNK_IMPORT),
-                      pn->pn_left->isKind(ParseNodeKind::PNK_IMPORT_SPEC_LIST));
-        MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::PNK_EXPORT_FROM),
-                      pn->pn_left->isKind(ParseNodeKind::PNK_EXPORT_SPEC_LIST));
+        MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::Import),
+                      pn->pn_left->isKind(ParseNodeKind::ImportSpecList));
+        MOZ_ASSERT_IF(pn->isKind(ParseNodeKind::ExportFrom),
+                      pn->pn_left->isKind(ParseNodeKind::ExportSpecList));
         MOZ_ASSERT(pn->pn_left->isArity(PN_LIST));
-        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::PNK_STRING));
+        MOZ_ASSERT(pn->pn_right->isKind(ParseNodeKind::String));
         stack->pushList(pn->pn_left);
         stack->push(pn->pn_right);
         return PushResult::Recyclable;
       }
 
-      case ParseNodeKind::PNK_EXPORT_DEFAULT: {
+      case ParseNodeKind::ExportDefault: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
-        MOZ_ASSERT_IF(pn->pn_right, pn->pn_right->isKind(ParseNodeKind::PNK_NAME));
+        MOZ_ASSERT_IF(pn->pn_right, pn->pn_right->isKind(ParseNodeKind::Name));
         stack->push(pn->pn_left);
         if (pn->pn_right)
             stack->push(pn->pn_right);
         return PushResult::Recyclable;
       }
 
       // Ternary nodes with all children non-null.
-      case ParseNodeKind::PNK_CONDITIONAL: {
+      case ParseNodeKind::Conditional: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         stack->push(pn->pn_kid1);
         stack->push(pn->pn_kid2);
         stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // For for-in and for-of, the first child is the left-hand side of the
       // 'in' or 'of' (a declaration or an assignment target). The second
       // child is always null, and the third child is the expression looped
       // over.  For example, in |for (var p in obj)|, the first child is |var
       // p|, the second child is null, and the third child is |obj|.
-      case ParseNodeKind::PNK_FORIN:
-      case ParseNodeKind::PNK_FOROF: {
+      case ParseNodeKind::ForIn:
+      case ParseNodeKind::ForOf: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         MOZ_ASSERT(!pn->pn_kid2);
         stack->push(pn->pn_kid1);
         stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // for (;;) nodes have one child per optional component of the loop head.
-      case ParseNodeKind::PNK_FORHEAD: {
+      case ParseNodeKind::ForHead: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         if (pn->pn_kid1)
             stack->push(pn->pn_kid1);
         if (pn->pn_kid2)
             stack->push(pn->pn_kid2);
         if (pn->pn_kid3)
             stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // classes might have an optional node for the heritage, as well as the names
-      case ParseNodeKind::PNK_CLASS: {
+      case ParseNodeKind::Class: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         if (pn->pn_kid1)
             stack->push(pn->pn_kid1);
         if (pn->pn_kid2)
             stack->push(pn->pn_kid2);
         stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // if-statement nodes have condition and consequent children and a
       // possibly-null alternative.
-      case ParseNodeKind::PNK_IF: {
+      case ParseNodeKind::If: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         stack->push(pn->pn_kid1);
         stack->push(pn->pn_kid2);
         if (pn->pn_kid3)
             stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // try-statements have statements to execute, and one or both of a
       // catch-list and a finally-block.
-      case ParseNodeKind::PNK_TRY: {
+      case ParseNodeKind::Try: {
         MOZ_ASSERT(pn->isArity(PN_TERNARY));
         MOZ_ASSERT(pn->pn_kid2 || pn->pn_kid3);
         stack->push(pn->pn_kid1);
         if (pn->pn_kid2)
             stack->push(pn->pn_kid2);
         if (pn->pn_kid3)
             stack->push(pn->pn_kid3);
         return PushResult::Recyclable;
       }
 
       // A catch node has left node as catch-variable pattern (or null if
       // omitted) and right node as the statements in the catch block.
-      case ParseNodeKind::PNK_CATCH: {
+      case ParseNodeKind::Catch: {
         MOZ_ASSERT(pn->isArity(PN_BINARY));
         if (pn->pn_left)
             stack->push(pn->pn_left);
         stack->push(pn->pn_right);
         return PushResult::Recyclable;
       }
 
       // List nodes with all non-null children.
-      case ParseNodeKind::PNK_OR:
-      case ParseNodeKind::PNK_AND:
-      case ParseNodeKind::PNK_BITOR:
-      case ParseNodeKind::PNK_BITXOR:
-      case ParseNodeKind::PNK_BITAND:
-      case ParseNodeKind::PNK_STRICTEQ:
-      case ParseNodeKind::PNK_EQ:
-      case ParseNodeKind::PNK_STRICTNE:
-      case ParseNodeKind::PNK_NE:
-      case ParseNodeKind::PNK_LT:
-      case ParseNodeKind::PNK_LE:
-      case ParseNodeKind::PNK_GT:
-      case ParseNodeKind::PNK_GE:
-      case ParseNodeKind::PNK_INSTANCEOF:
-      case ParseNodeKind::PNK_IN:
-      case ParseNodeKind::PNK_LSH:
-      case ParseNodeKind::PNK_RSH:
-      case ParseNodeKind::PNK_URSH:
-      case ParseNodeKind::PNK_ADD:
-      case ParseNodeKind::PNK_SUB:
-      case ParseNodeKind::PNK_STAR:
-      case ParseNodeKind::PNK_DIV:
-      case ParseNodeKind::PNK_MOD:
-      case ParseNodeKind::PNK_POW:
-      case ParseNodeKind::PNK_PIPELINE:
-      case ParseNodeKind::PNK_COMMA:
-      case ParseNodeKind::PNK_NEW:
-      case ParseNodeKind::PNK_CALL:
-      case ParseNodeKind::PNK_SUPERCALL:
-      case ParseNodeKind::PNK_ARRAY:
-      case ParseNodeKind::PNK_OBJECT:
-      case ParseNodeKind::PNK_TEMPLATE_STRING_LIST:
-      case ParseNodeKind::PNK_TAGGED_TEMPLATE:
-      case ParseNodeKind::PNK_CALLSITEOBJ:
-      case ParseNodeKind::PNK_VAR:
-      case ParseNodeKind::PNK_CONST:
-      case ParseNodeKind::PNK_LET:
-      case ParseNodeKind::PNK_STATEMENTLIST:
-      case ParseNodeKind::PNK_IMPORT_SPEC_LIST:
-      case ParseNodeKind::PNK_EXPORT_SPEC_LIST:
-      case ParseNodeKind::PNK_PARAMSBODY:
-      case ParseNodeKind::PNK_CLASSMETHODLIST:
+      case ParseNodeKind::Or:
+      case ParseNodeKind::And:
+      case ParseNodeKind::BitOr:
+      case ParseNodeKind::BitXor:
+      case ParseNodeKind::BitAnd:
+      case ParseNodeKind::StrictEq:
+      case ParseNodeKind::Eq:
+      case ParseNodeKind::StrictNe:
+      case ParseNodeKind::Ne:
+      case ParseNodeKind::Lt:
+      case ParseNodeKind::Le:
+      case ParseNodeKind::Gt:
+      case ParseNodeKind::Ge:
+      case ParseNodeKind::InstanceOf:
+      case ParseNodeKind::In:
+      case ParseNodeKind::Lsh:
+      case ParseNodeKind::Rsh:
+      case ParseNodeKind::Ursh:
+      case ParseNodeKind::Add:
+      case ParseNodeKind::Sub:
+      case ParseNodeKind::Star:
+      case ParseNodeKind::Div:
+      case ParseNodeKind::Mod:
+      case ParseNodeKind::Pow:
+      case ParseNodeKind::Pipeline:
+      case ParseNodeKind::Comma:
+      case ParseNodeKind::New:
+      case ParseNodeKind::Call:
+      case ParseNodeKind::SuperCall:
+      case ParseNodeKind::Array:
+      case ParseNodeKind::Object:
+      case ParseNodeKind::TemplateStringList:
+      case ParseNodeKind::TaggedTemplate:
+      case ParseNodeKind::CallSiteObj:
+      case ParseNodeKind::Var:
+      case ParseNodeKind::Const:
+      case ParseNodeKind::Let:
+      case ParseNodeKind::StatementList:
+      case ParseNodeKind::ImportSpecList:
+      case ParseNodeKind::ExportSpecList:
+      case ParseNodeKind::ParamsBody:
+      case ParseNodeKind::ClassMethodList:
         return PushListNodeChildren(pn, stack);
 
-      case ParseNodeKind::PNK_LABEL:
-      case ParseNodeKind::PNK_DOT:
-      case ParseNodeKind::PNK_NAME:
+      case ParseNodeKind::Label:
+      case ParseNodeKind::Dot:
+      case ParseNodeKind::Name:
         return PushNameNodeChildren(pn, stack);
 
-      case ParseNodeKind::PNK_LEXICALSCOPE:
+      case ParseNodeKind::LexicalScope:
         return PushScopeNodeChildren(pn, stack);
 
-      case ParseNodeKind::PNK_FUNCTION:
-      case ParseNodeKind::PNK_MODULE:
+      case ParseNodeKind::Function:
+      case ParseNodeKind::Module:
         return PushCodeNodeChildren(pn, stack);
 
-      case ParseNodeKind::PNK_LIMIT: // invalid sentinel value
+      case ParseNodeKind::Limit: // invalid sentinel value
         MOZ_CRASH("invalid node kind");
     }
 
     MOZ_CRASH("bad ParseNodeKind");
     return PushResult::CleanUpLater;
 }
 
 /*
@@ -570,17 +570,17 @@ ParseNode::appendOrCreateList(ParseNodeK
         //
         // (**) is right-associative; per spec |a ** b ** c| parses as
         // (** a (** b c)). But we treat this the same way, creating a list
         // node: (** a b c). All consumers must understand that this must be
         // processed with a right fold, whereas the list (+ a b c) must be
         // processed with a left fold because (+) is left-associative.
         //
         if (left->isKind(kind) &&
-            (kind == ParseNodeKind::PNK_POW ? !left->pn_parens : left->isBinaryOperation()))
+            (kind == ParseNodeKind::Pow ? !left->pn_parens : left->isBinaryOperation()))
         {
             ListNode* list = &left->as<ListNode>();
 
             list->append(right);
             list->pn_pos.end = right->pn_pos.end;
 
             return list;
         }
@@ -667,34 +667,34 @@ ParseNode::dump(GenericPrinter& out, int
         break;
     }
 }
 
 void
 NullaryNode::dump(GenericPrinter& out)
 {
     switch (getKind()) {
-      case ParseNodeKind::PNK_TRUE:  out.put("#true");  break;
-      case ParseNodeKind::PNK_FALSE: out.put("#false"); break;
-      case ParseNodeKind::PNK_NULL:  out.put("#null");  break;
-      case ParseNodeKind::PNK_RAW_UNDEFINED: out.put("#undefined"); break;
+      case ParseNodeKind::True:  out.put("#true");  break;
+      case ParseNodeKind::False: out.put("#false"); break;
+      case ParseNodeKind::Null:  out.put("#null");  break;
+      case ParseNodeKind::RawUndefined: out.put("#undefined"); break;
 
-      case ParseNodeKind::PNK_NUMBER: {
+      case ParseNodeKind::Number: {
         ToCStringBuf cbuf;
         const char* cstr = NumberToCString(nullptr, &cbuf, pn_dval);
         if (!IsFinite(pn_dval))
             out.put("#");
         if (cstr)
             out.printf("%s", cstr);
         else
             out.printf("%g", pn_dval);
         break;
       }
 
-      case ParseNodeKind::PNK_STRING:
+      case ParseNodeKind::String:
         pn_atom->dumpCharsNoNewline(out);
         break;
 
       default:
         out.printf("(%s)", parseNodeNames[size_t(getKind())]);
     }
 }
 
@@ -778,18 +778,18 @@ DumpName(GenericPrinter& out, const Char
         else
             out.printf("\\u%04x", unsigned(c));
     }
 }
 
 void
 NameNode::dump(GenericPrinter& out, int indent)
 {
-    if (isKind(ParseNodeKind::PNK_NAME) || isKind(ParseNodeKind::PNK_DOT)) {
-        if (isKind(ParseNodeKind::PNK_DOT))
+    if (isKind(ParseNodeKind::Name) || isKind(ParseNodeKind::Dot)) {
+        if (isKind(ParseNodeKind::Dot))
             out.put("(.");
 
         if (!pn_atom) {
             out.put("#<null name>");
         } else if (getOp() == JSOP_GETARG && pn_atom->length() == 0) {
             // Dump destructuring parameter.
             out.put("(#<zero-length name> ");
             DumpParseTree(expr(), out, indent + 21);
@@ -797,17 +797,17 @@ NameNode::dump(GenericPrinter& out, int 
         } else {
             JS::AutoCheckCannotGC nogc;
             if (pn_atom->hasLatin1Chars())
                 DumpName(out, pn_atom->latin1Chars(nogc), pn_atom->length());
             else
                 DumpName(out, pn_atom->twoByteChars(nogc), pn_atom->length());
         }
 
-        if (isKind(ParseNodeKind::PNK_DOT)) {
+        if (isKind(ParseNodeKind::Dot)) {
             out.putChar(' ');
             if (as<PropertyAccess>().isSuper())
                 out.put("super");
             else
                 DumpParseTree(expr(), out, indent + 2);
             out.printf(")");
         }
         return;
@@ -897,17 +897,17 @@ FunctionBox::trace(JSTracer* trc)
 bool
 js::frontend::IsAnonymousFunctionDefinition(ParseNode* pn)
 {
     // ES 2017 draft
     // 12.15.2 (ArrowFunction, AsyncArrowFunction).
     // 14.1.12 (FunctionExpression).
     // 14.4.8 (GeneratorExpression).
     // 14.6.8 (AsyncFunctionExpression)
-    if (pn->isKind(ParseNodeKind::PNK_FUNCTION) && !pn->pn_funbox->function()->explicitName())
+    if (pn->isKind(ParseNodeKind::Function) && !pn->pn_funbox->function()->explicitName())
         return true;
 
     // 14.5.8 (ClassExpression)
     if (pn->is<ClassNode>() && !pn->as<ClassNode>().names())
         return true;
 
     return false;
 }
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -38,405 +38,405 @@ namespace js {
 namespace frontend {
 
 class ParseContext;
 class FullParseHandler;
 class FunctionBox;
 class ObjectBox;
 
 #define FOR_EACH_PARSE_NODE_KIND(F) \
-    F(NOP) \
-    F(SEMI) \
-    F(COMMA) \
-    F(CONDITIONAL) \
-    F(COLON) \
-    F(SHORTHAND) \
-    F(POS) \
-    F(NEG) \
-    F(PREINCREMENT) \
-    F(POSTINCREMENT) \
-    F(PREDECREMENT) \
-    F(POSTDECREMENT) \
-    F(DOT) \
-    F(ELEM) \
-    F(ARRAY) \
-    F(ELISION) \
-    F(STATEMENTLIST) \
-    F(LABEL) \
-    F(OBJECT) \
-    F(CALL) \
-    F(NAME) \
-    F(OBJECT_PROPERTY_NAME) \
-    F(COMPUTED_NAME) \
-    F(NUMBER) \
-    F(STRING) \
-    F(TEMPLATE_STRING_LIST) \
-    F(TEMPLATE_STRING) \
-    F(TAGGED_TEMPLATE) \
-    F(CALLSITEOBJ) \
-    F(REGEXP) \
-    F(TRUE) \
-    F(FALSE) \
-    F(NULL) \
-    F(RAW_UNDEFINED) \
-    F(THIS) \
-    F(FUNCTION) \
-    F(MODULE) \
-    F(IF) \
-    F(SWITCH) \
-    F(CASE) \
-    F(WHILE) \
-    F(DOWHILE) \
-    F(FOR) \
-    F(BREAK) \
-    F(CONTINUE) \
-    F(VAR) \
-    F(CONST) \
-    F(WITH) \
-    F(RETURN) \
-    F(NEW) \
+    F(Nop) \
+    F(Semi) \
+    F(Comma) \
+    F(Conditional) \
+    F(Colon) \
+    F(Shorthand) \
+    F(Pos) \
+    F(Neg) \
+    F(PreIncrement) \
+    F(PostIncrement) \
+    F(PreDecrement) \
+    F(PostDecrement) \
+    F(Dot) \
+    F(Elem) \
+    F(Array) \
+    F(Elision) \
+    F(StatementList) \
+    F(Label) \
+    F(Object) \
+    F(Call) \
+    F(Name) \
+    F(ObjectPropertyName) \
+    F(ComputedName) \
+    F(Number) \
+    F(String) \
+    F(TemplateStringList) \
+    F(TemplateString) \
+    F(TaggedTemplate) \
+    F(CallSiteObj) \
+    F(RegExp) \
+    F(True) \
+    F(False) \
+    F(Null) \
+    F(RawUndefined) \
+    F(This) \
+    F(Function) \
+    F(Module) \
+    F(If) \
+    F(Switch) \
+    F(Case) \
+    F(While) \
+    F(DoWhile) \
+    F(For) \
+    F(Break) \
+    F(Continue) \
+    F(Var) \
+    F(Const) \
+    F(With) \
+    F(Return) \
+    F(New) \
     /* Delete operations.  These must be sequential. */ \
-    F(DELETENAME) \
-    F(DELETEPROP) \
-    F(DELETEELEM) \
-    F(DELETEEXPR) \
-    F(TRY) \
-    F(CATCH) \
-    F(THROW) \
-    F(DEBUGGER) \
-    F(GENERATOR) \
-    F(INITIALYIELD) \
-    F(YIELD) \
-    F(YIELD_STAR) \
-    F(LEXICALSCOPE) \
-    F(LET) \
-    F(IMPORT) \
-    F(IMPORT_SPEC_LIST) \
-    F(IMPORT_SPEC) \
-    F(EXPORT) \
-    F(EXPORT_FROM) \
-    F(EXPORT_DEFAULT) \
-    F(EXPORT_SPEC_LIST) \
-    F(EXPORT_SPEC) \
-    F(EXPORT_BATCH_SPEC) \
-    F(FORIN) \
-    F(FOROF) \
-    F(FORHEAD) \
-    F(PARAMSBODY) \
-    F(SPREAD) \
-    F(MUTATEPROTO) \
-    F(CLASS) \
-    F(CLASSMETHOD) \
-    F(CLASSMETHODLIST) \
-    F(CLASSNAMES) \
-    F(NEWTARGET) \
-    F(POSHOLDER) \
-    F(SUPERBASE) \
-    F(SUPERCALL) \
-    F(SETTHIS) \
+    F(DeleteName) \
+    F(DeleteProp) \
+    F(DeleteElem) \
+    F(DeleteExpr) \
+    F(Try) \
+    F(Catch) \
+    F(Throw) \
+    F(Debugger) \
+    F(Generator) \
+    F(InitialYield) \
+    F(Yield) \
+    F(YieldStar) \
+    F(LexicalScope) \
+    F(Let) \
+    F(Import) \
+    F(ImportSpecList) \
+    F(ImportSpec) \
+    F(Export) \
+    F(ExportFrom) \
+    F(ExportDefault) \
+    F(ExportSpecList) \
+    F(ExportSpec) \
+    F(ExportBatchSpec) \
+    F(ForIn) \
+    F(ForOf) \
+    F(ForHead) \
+    F(ParamsBody) \
+    F(Spread) \
+    F(MutateProto) \
+    F(Class) \
+    F(ClassMethod) \
+    F(ClassMethodList) \
+    F(ClassNames) \
+    F(NewTarget) \
+    F(PosHolder) \
+    F(SuperBase) \
+    F(SuperCall) \
+    F(SetThis) \
     \
     /* Unary operators. */ \
-    F(TYPEOFNAME) \
-    F(TYPEOFEXPR) \
-    F(VOID) \
-    F(NOT) \
-    F(BITNOT) \
-    F(AWAIT) \
+    F(TypeOfName) \
+    F(TypeOfExpr) \
+    F(Void) \
+    F(Not) \
+    F(BitNot) \
+    F(Await) \
     \
     /* \
      * Binary operators. \
      * These must be in the same order as TOK_OR and friends in TokenStream.h. \
      */ \
-    F(PIPELINE) \
-    F(OR) \
-    F(AND) \
-    F(BITOR) \
-    F(BITXOR) \
-    F(BITAND) \
-    F(STRICTEQ) \
-    F(EQ) \
-    F(STRICTNE) \
-    F(NE) \
-    F(LT) \
-    F(LE) \
-    F(GT) \
-    F(GE) \
-    F(INSTANCEOF) \
-    F(IN) \
-    F(LSH) \
-    F(RSH) \
-    F(URSH) \
-    F(ADD) \
-    F(SUB) \
-    F(STAR) \
-    F(DIV) \
-    F(MOD) \
-    F(POW) \
+    F(Pipeline) \
+    F(Or) \
+    F(And) \
+    F(BitOr) \
+    F(BitXor) \
+    F(BitAnd) \
+    F(StrictEq) \
+    F(Eq) \
+    F(StrictNe) \
+    F(Ne) \
+    F(Lt) \
+    F(Le) \
+    F(Gt) \
+    F(Ge) \
+    F(InstanceOf) \
+    F(In) \
+    F(Lsh) \
+    F(Rsh) \
+    F(Ursh) \
+    F(Add) \
+    F(Sub) \
+    F(Star) \
+    F(Div) \
+    F(Mod) \
+    F(Pow) \
     \
     /* Assignment operators (= += -= etc.). */ \
     /* ParseNode::isAssignment assumes all these are consecutive. */ \
-    F(ASSIGN) \
-    F(ADDASSIGN) \
-    F(SUBASSIGN) \
-    F(BITORASSIGN) \
-    F(BITXORASSIGN) \
-    F(BITANDASSIGN) \
-    F(LSHASSIGN) \
-    F(RSHASSIGN) \
-    F(URSHASSIGN) \
-    F(MULASSIGN) \
-    F(DIVASSIGN) \
-    F(MODASSIGN) \
-    F(POWASSIGN)
+    F(Assign) \
+    F(AddAssign) \
+    F(SubAssign) \
+    F(BitOrAssign) \
+    F(BitXorAssign) \
+    F(BitAndAssign) \
+    F(LshAssign) \
+    F(RshAssign) \
+    F(UrshAssign) \
+    F(MulAssign) \
+    F(DivAssign) \
+    F(ModAssign) \
+    F(PowAssign)
 
 /*
  * Parsing builds a tree of nodes that directs code generation.  This tree is
  * not a concrete syntax tree in all respects (for example, || and && are left
  * associative, but (A && B && C) translates into the right-associated tree
  * <A && <B && C>> so that code generation can emit a left-associative branch
  * around <B && C> when A is false).  Nodes are labeled by kind, with a
  * secondary JSOp label when needed.
  *
  * The long comment after this enum block describes the kinds in detail.
  */
 enum class ParseNodeKind : uint16_t
 {
-#define EMIT_ENUM(name) PNK_##name,
+#define EMIT_ENUM(name) name,
     FOR_EACH_PARSE_NODE_KIND(EMIT_ENUM)
 #undef EMIT_ENUM
-    PNK_LIMIT, /* domain size */
-    PNK_BINOP_FIRST = ParseNodeKind::PNK_PIPELINE,
-    PNK_BINOP_LAST = ParseNodeKind::PNK_POW,
-    PNK_ASSIGNMENT_START = ParseNodeKind::PNK_ASSIGN,
-    PNK_ASSIGNMENT_LAST = ParseNodeKind::PNK_POWASSIGN
+    Limit, /* domain size */
+    BinOpFirst = ParseNodeKind::Pipeline,
+    BinOpLast = ParseNodeKind::Pow,
+    AssignmentStart = ParseNodeKind::Assign,
+    AssignmentLast = ParseNodeKind::PowAssign
 };
 
 inline bool
 IsDeleteKind(ParseNodeKind kind)
 {
-    return ParseNodeKind::PNK_DELETENAME <= kind && kind <= ParseNodeKind::PNK_DELETEEXPR;
+    return ParseNodeKind::DeleteName <= kind && kind <= ParseNodeKind::DeleteExpr;
 }
 
 inline bool
 IsTypeofKind(ParseNodeKind kind)
 {
-    return ParseNodeKind::PNK_TYPEOFNAME <= kind && kind <= ParseNodeKind::PNK_TYPEOFEXPR;
+    return ParseNodeKind::TypeOfName <= kind && kind <= ParseNodeKind::TypeOfExpr;
 }
 
 /*
  * Label        Variant     Members
  * -----        -------     -------
  * <Definitions>
- * PNK_FUNCTION name        pn_funbox: ptr to js::FunctionBox holding function
+ * Function name        pn_funbox: ptr to js::FunctionBox holding function
  *                            object containing arg and var properties.  We
  *                            create the function object at parse (not emit)
  *                            time to specialize arg and var bytecodes early.
- *                          pn_body: PNK_PARAMSBODY, ordinarily;
- *                            ParseNodeKind::PNK_LEXICALSCOPE for implicit function in genexpr
- * PNK_PARAMSBODY list      list of formal parameters with
- *                              PNK_NAME node with non-empty name for
+ *                          pn_body: ParamsBody, ordinarily;
+ *                            ParseNodeKind::LexicalScope for implicit function in genexpr
+ * ParamsBody list      list of formal parameters with
+ *                              Name node with non-empty name for
  *                                SingleNameBinding without Initializer
- *                              PNK_ASSIGN node for SingleNameBinding with
+ *                              Assign node for SingleNameBinding with
  *                                Initializer
- *                              PNK_NAME node with empty name for destructuring
- *                                pn_expr: PNK_ARRAY, PNK_OBJECT, or PNK_ASSIGN
- *                                  PNK_ARRAY or PNK_OBJECT for BindingPattern
+ *                              Name node with empty name for destructuring
+ *                                pn_expr: Array, Object, or Assign
+ *                                  Array or Object for BindingPattern
  *                                    without Initializer
- *                                  PNK_ASSIGN for BindingPattern with
+ *                                  Assign for BindingPattern with
  *                                    Initializer
  *                          followed by:
- *                              PNK_STATEMENTLIST node for function body
+ *                              StatementList node for function body
  *                                statements,
- *                              PNK_RETURN for expression closure
+ *                              Return for expression closure
  *                          pn_count: 1 + number of formal parameters
- *                          pn_tree: PNK_PARAMSBODY or PNK_STATEMENTLIST node
- * PNK_SPREAD   unary       pn_kid: expression being spread
+ *                          pn_tree: ParamsBody or StatementList node
+ * Spread   unary       pn_kid: expression being spread
  *
  * <Statements>
- * PNK_STATEMENTLIST list   pn_head: list of pn_count statements
- * PNK_IF       ternary     pn_kid1: cond, pn_kid2: then, pn_kid3: else or null.
- * PNK_SWITCH   binary      pn_left: discriminant
- *                          pn_right: list of PNK_CASE nodes, with at most one
+ * StatementList list   pn_head: list of pn_count statements
+ * If       ternary     pn_kid1: cond, pn_kid2: then, pn_kid3: else or null.
+ * Switch   binary      pn_left: discriminant
+ *                          pn_right: list of Case nodes, with at most one
  *                            default node, or if there are let bindings
  *                            in the top level of the switch body's cases, a
- *                            PNK_LEXICALSCOPE node that contains the list of
- *                            PNK_CASE nodes.
- * PNK_CASE     binary      pn_left: case-expression if CaseClause, or
+ *                            LexicalScope node that contains the list of
+ *                            Case nodes.
+ * Case     binary      pn_left: case-expression if CaseClause, or
  *                            null if DefaultClause
- *                          pn_right: PNK_STATEMENTLIST node for this case's
+ *                          pn_right: StatementList node for this case's
  *                            statements
  *                          pn_u.binary.offset: scratch space for the emitter
- * PNK_WHILE    binary      pn_left: cond, pn_right: body
- * PNK_DOWHILE  binary      pn_left: body, pn_right: cond
- * PNK_FOR      binary      pn_left: either PNK_FORIN (for-in statement),
- *                            PNK_FOROF (for-of) or PNK_FORHEAD (for(;;))
+ * While    binary      pn_left: cond, pn_right: body
+ * DoWhile  binary      pn_left: body, pn_right: cond
+ * For      binary      pn_left: either ForIn (for-in statement),
+ *                            ForOf (for-of) or ForHead (for(;;))
  *                          pn_right: body
- * PNK_FORIN    ternary     pn_kid1: declaration or expression to left