--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -110,27 +110,25 @@ private:
     bool parseScope(SimpleTokenReader* reader, ScopeData& out);
     bool parseExpression(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parsePropertyName(SimpleTokenReader* reader, UniquePtr<PropertyName>& out);
     bool parseBlockStatement(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     bool parseCatchClause(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     bool parseVariableDeclarator(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
 
     // --- Parse lists of nodes.
-    //
-    // By convention, all parse*List() that take a `UniquePtr<ParseNode>`
-    // construct an instance of `ListNode`. Since `ListNode` cannot represent
-    // `nullptr`, we follow the conventions of `PNK_ARRAY` and represent
-    // null nodes as `PNK_ELISIION`.
+
+
+    // Produces a list of expressions. Empty expressions are replaced with PNK_ELISION.
+    bool parseExpressionOrElisionList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
 
     bool parseStringList(SimpleTokenReader* reader, MutableHandle<Maybe<Names>> out);
     bool parseStringList(SimpleTokenReader* reader, MutableHandle<Names> out);
     bool parseStringSet(SimpleTokenReader* reader, MutableHandle<Maybe<NameBag>>);
     bool parseStringSet(SimpleTokenReader* reader, MutableHandle<NameBag>);
-    bool parseExpressionList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parseSwitchCaseList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out);
     bool parsePatternList(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     bool parseDirectiveList(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
     // Returns a list of PNK_COLON.
     bool parseKeyValueList(SimpleTokenReader* reader, UniquePtr<ParseNode>&);
 
     // --- Parse the contents of a node whose kind has already been determined.
 
@@ -1519,17 +1517,17 @@ ASTReader::parseExpression(SimpleTokenRe
             }
             Unused << thisName.release();
 
             out = Move(result);
             break;
         }
         case BinKind::array_expression: {
             UniquePtr<ParseNode> result;
-            if (!this->parseExpressionList(&sub, result)) {
+            if (!this->parseExpressionOrElisionList(&sub, result)) {
                 return false;
             }
 
             result->setKind(PNK_ARRAY);
             result->setOp(JSOP_NEWINIT);
             out = Move(result);
             break;
         }
@@ -1967,17 +1965,17 @@ ASTReader::parseExpression(SimpleTokenRe
             for (auto field: fields) {
                 switch (field) {
                     case BinField::callee:
                         if (!this->parseExpression(&sub, callee)) {
                             return false;
                         }
                         break;
                     case BinField::arguments:
-                        if (!this->parseExpressionList(&sub, arguments)) {
+                        if (!this->parseExpressionOrElisionList(&sub, arguments)) {
                             return false;
                         }
                         break;
                     default:
                         return this->raiseError();
                 }
             }
 
@@ -1997,17 +1995,17 @@ ASTReader::parseExpression(SimpleTokenRe
             break;
         }
         case BinKind::sequence_expression: {
             UniquePtr<ParseNode> sequence;
 
             for (auto field: fields) {
                 switch (field) {
                     case BinField::expressions:
-                        if (!this->parseExpressionList(&sub, sequence)) {
+                        if (!this->parseExpressionOrElisionList(&sub, sequence)) {
                             return false;
                         }
                         break;
                     default:
                         return this->raiseError();
                 }
             }
 
@@ -2124,17 +2122,17 @@ ASTReader::parseVariableDeclarator(Simpl
         result->pn_right = init.release();
     }
 
     out = Move(result);
     return true;
 }
 
 bool
-ASTReader::parseExpressionList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out) {
+ASTReader::parseExpressionOrElisionList(SimpleTokenReader* reader, UniquePtr<ParseNode>& out) {
     if (out) {
         return this->raiseError();
     }
 
     uint32_t length;
     SimpleTokenReader sub(this->cx);
 
     if (!reader->readList(&length, &sub)) {