--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -104,17 +104,16 @@ private:
 
     // --- Parse full nodes.
 
     bool parseBlockStatement(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     bool parseCatchClause(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     bool parseExpression(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parsePattern(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parseProgram(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
-    bool parsePropertyName(SimpleTokenReader* reader, UniquePtr<PropertyName>& out);
     bool parseScope(SimpleTokenReader* reader, ScopeData& out);
     bool parseStatement(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parseStatementList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parseSwitchCase(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parseVariableDeclarator(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
 
     // --- Parse lists of nodes.
 
@@ -607,23 +606,23 @@ ASTReader::parseStatement(SimpleTokenRea
                 return this->raiseError();
             }
 
             Unused << arg.release();
             out = Move(result);
             break;
         }
         case BinKind::labeled_statement: {
-            UniquePtr<PropertyName> label;
+            Rooted<PropertyName*> label(this->cx);
             UniquePtr<ParseNode> body;
 
             for (auto field: fields) {
                 switch (field) {
                     case BinField::label:
-                        if (!this->parsePropertyName(&sub, label)) {
+                        if (!this->readString(&sub, &label)) {
                             return false;
                         }
                         break;
                     case BinField::body:
                         if (!this->parseStatement(&sub, body)) {
                             return false;
                         }
                         break;
@@ -636,30 +635,29 @@ ASTReader::parseStatement(SimpleTokenRea
                 return this->raiseError();
             }
 
             UniquePtr<ParseNode> result(new_<LabeledStatement>(label.get(), body.get(), 0));
             if (!result) {
                 return false;
             }
 
-            Unused << label.release();
             Unused << body.release();
             out = Move(result);
             break;
     }
     case BinKind::break_statement: MOZ_FALLTHROUGH;
     case BinKind::continue_statement: {
 
-        UniquePtr<PropertyName> label;
+        Rooted<PropertyName*> label(this->cx);
 
         for (auto field: fields) {
             switch (field) {
                 case BinField::label:
-                    if (!this->parsePropertyName(&sub, label)) {
+                    if (!this->readString(&sub, &label)) {
                         return false;
                     }
                     break;
                 default:
                     return this->raiseError();
             }
         }
 
@@ -676,17 +674,16 @@ ASTReader::parseStatement(SimpleTokenRea
         } else {
             UniquePtr<ParseNode> result(new_<ContinueStatement>(label.get(), TokenPos()));
             if (!result) {
                 return false;
             }
             out = Move(result);
         }
 
-        Unused << label.release();
         break;
 
     }
     case BinKind::if_statement: {
 
         UniquePtr<ParseNode> test;
         UniquePtr<ParseNode> consequent;
         UniquePtr<ParseNode> alternate; // Optional
@@ -2228,17 +2225,16 @@ ASTReader::parseDirectiveList(SimpleToke
         if (!this->readString(&sub, string)) {
             return false;
         }
     }
 
     return true;
 }
 
-
 bool
 ASTReader::readNumber(SimpleTokenReader* reader, Maybe<double>& out) {
     if (out) {
         return this->raiseError();
     }
 
     return reader->readMaybeF64(&out);
 }