--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -8562,122 +8562,128 @@ Parser<ParseHandler>::newName(PropertyNa
 template <typename ParseHandler>
 typename ParseHandler::Node
 Parser<ParseHandler>::newName(PropertyName* name, TokenPos pos)
 {
     return handler.newName(name, pos, context);
 }
 
 template <typename ParseHandler>
-PropertyName*
-Parser<ParseHandler>::checkLabelOrIdentifierReference(PropertyName* ident,
+bool
+Parser<ParseHandler>::checkLabelOrIdentifierReference(HandlePropertyName ident,
                                                       uint32_t offset,
                                                       YieldHandling yieldHandling)
 {
     if (ident == context->names().yield) {
         if (yieldHandling == YieldIsKeyword ||
             versionNumber() >= JSVERSION_1_7)
         {
             errorAt(offset, JSMSG_RESERVED_ID, "yield");
-            return nullptr;
+            return false;
         }
         if (pc->sc()->needStrictChecks()) {
             if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "yield"))
-                return nullptr;
-        }
-
-        return ident;
+                return false;
+        }
+
+        return true;
     }
 
     if (ident == context->names().await) {
         if (awaitIsKeyword()) {
             errorAt(offset, JSMSG_RESERVED_ID, "await");
-            return nullptr;
-        }
-        return ident;
+            return false;
+        }
+        return true;
     }
 
     if (IsKeyword(ident) || IsReservedWordLiteral(ident)) {
         errorAt(offset, JSMSG_INVALID_ID, ReservedWordToCharZ(ident));
-        return nullptr;
+        return false;
     }
 
     if (IsFutureReservedWord(ident)) {
         errorAt(offset, JSMSG_RESERVED_ID, ReservedWordToCharZ(ident));
-        return nullptr;
+        return false;
     }
 
     if (pc->sc()->needStrictChecks()) {
         if (IsStrictReservedWord(ident)) {
             if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, ReservedWordToCharZ(ident)))
-                return nullptr;
-            return ident;
+                return false;
+            return true;
         }
 
         if (ident == context->names().let) {
             if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "let"))
-                return nullptr;
-            return ident;
+                return false;
+            return true;
         }
 
         if (ident == context->names().static_) {
             if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "static"))
-                return nullptr;
-            return ident;
-        }
-    }
-
-    return ident;
-}
-
-template <typename ParseHandler>
-PropertyName*
-Parser<ParseHandler>::checkBindingIdentifier(PropertyName* ident,
+                return false;
+            return true;
+        }
+    }
+
+    return true;
+}
+
+template <typename ParseHandler>
+bool
+Parser<ParseHandler>::checkBindingIdentifier(HandlePropertyName ident,
                                              uint32_t offset,
                                              YieldHandling yieldHandling)
 {
     if (!checkLabelOrIdentifierReference(ident, offset, yieldHandling))
-        return nullptr;
+        return false;
 
     if (pc->sc()->needStrictChecks()) {
         if (ident == context->names().arguments) {
             if (!strictModeErrorAt(offset, JSMSG_BAD_STRICT_ASSIGN, "arguments"))
-                return nullptr;
-            return ident;
+                return false;
+            return true;
         }
 
         if (ident == context->names().eval) {
             if (!strictModeErrorAt(offset, JSMSG_BAD_STRICT_ASSIGN, "eval"))
-                return nullptr;
-            return ident;
-        }
-    }
-
-    return ident;
+                return false;
+            return true;
+        }
+    }
+
+    return true;
 }
 
 template <typename ParseHandler>
 PropertyName*
 Parser<ParseHandler>::labelOrIdentifierReference(YieldHandling yieldHandling)
 {
     // ES 2017 draft 12.1.1.
     //   StringValue of IdentifierName normalizes any Unicode escape sequences
     //   in IdentifierName hence such escapes cannot be used to write an
     //   Identifier whose code point sequence is the same as a ReservedWord.
     //
     // Use PropertyName* instead of TokenKind to reflect the normalization.
 
-    return checkLabelOrIdentifierReference(tokenStream.currentName(), pos().begin, yieldHandling);
+    RootedPropertyName ident(context, tokenStream.currentName());
+    if (!checkLabelOrIdentifierReference(ident, pos().begin, yieldHandling))
+        return nullptr;
+    return ident;
 }
 
 template <typename ParseHandler>
 PropertyName*
 Parser<ParseHandler>::bindingIdentifier(YieldHandling yieldHandling)
 {
-    return checkBindingIdentifier(tokenStream.currentName(), pos().begin, yieldHandling);
+    RootedPropertyName ident(context, tokenStream.currentName());
+    if (!checkBindingIdentifier(ident, pos().begin, yieldHandling))
+        return nullptr;
+    return ident;
 }
 
 template <typename ParseHandler>
 typename ParseHandler::Node
 Parser<ParseHandler>::identifierReference(Handle<PropertyName*> name)
 {
     Node pn = newName(name);
     if (!pn)

--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -1324,24 +1324,24 @@ class Parser final : public ParserBase, 
     bool namedImportsOrNamespaceImport(TokenKind tt, Node importSpecSet);
     bool checkExportedName(JSAtom* exportName);
     bool checkExportedNamesForDeclaration(Node node);
 
     enum ClassContext { ClassStatement, ClassExpression };
     Node classDefinition(YieldHandling yieldHandling, ClassContext classContext,
                          DefaultHandling defaultHandling);
 
-    PropertyName* checkLabelOrIdentifierReference(PropertyName* ident,
-                                                  uint32_t offset,
-                                                  YieldHandling yieldHandling);
-
-    PropertyName* checkBindingIdentifier(PropertyName* ident,
+    bool checkLabelOrIdentifierReference(HandlePropertyName ident,
                                          uint32_t offset,
                                          YieldHandling yieldHandling);
 
+    bool checkBindingIdentifier(HandlePropertyName ident,
+                                uint32_t offset,
+                                YieldHandling yieldHandling);
+
     PropertyName* labelOrIdentifierReference(YieldHandling yieldHandling);
 
     PropertyName* labelIdentifier(YieldHandling yieldHandling) {
         return labelOrIdentifierReference(yieldHandling);
     }
 
     PropertyName* identifierReference(YieldHandling yieldHandling) {
         return labelOrIdentifierReference(yieldHandling);