--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -267,16 +267,19 @@ ASTReader::parseScope(SimpleTokenReader*
     BinKind kind;
     SimpleTokenReader::BinFields fields(this->cx);
     SimpleTokenReader sub(this->cx);
 
     if (!reader->taggedTuple(kind, fields, &sub)) {
         return false;
     }
 
+    if (kind == BinKind::binjs_null) {
+        return true;
+    }
     if (kind != BinKind::binjs_scope) {
         return this->raiseError();
     }
 
     for (auto field: fields) {
         switch (field) {
             case BinField::has_direct_eval:
                 if (!this->parseBool(reader, &out.hasDirectEval)) {
@@ -464,16 +467,19 @@ ASTReader::parseStatement(SimpleTokenRea
     }
     BinKind kind;
     SimpleTokenReader::BinFields fields(this->cx);
     SimpleTokenReader sub(this->cx);
 
     if (!reader->taggedTuple(kind, fields, &sub)) {
         return false;
     }
+    if (kind == BinKind::binjs_null) {
+        return true;
+    }
 
     switch (kind) {
         case BinKind::empty_statement: {
             UniquePtr<ParseNode> result(new_<NullaryNode>(PNK_NOP, TokenPos()));
             if (!result) {
                 return false;
             }
             out = Move(result);
@@ -892,16 +898,22 @@ ASTReader::parseStatement(SimpleTokenRea
                     SimpleTokenReader::BinFields subFields(this->cx);
                     SimpleTokenReader subSub(this->cx);
                     BinKind subKind;
 
                     if (!sub.taggedTuple(subKind, subFields, &subSub)) {
                         return false;
                     }
 
+                    if (subKind == BinKind::binjs_null) {
+                        if (init) {
+                            return false;
+                        }
+                        break;
+                    }
                     if (subKind == BinKind::variable_declaration) {
                         if (!this->parseVariableDeclarationAux(&subSub, subKind, subFields, init)) {
                             return false;
                         }
                     } else /* Parse as expression */ {
                         if (!this->parseExpressionAux(&subSub, subKind, subFields, init)) {
                             return false;
                         }
@@ -972,17 +984,22 @@ ASTReader::parseStatement(SimpleTokenRea
                     // This can be either a VarDecl or a Pattern.
                     SimpleTokenReader::BinFields subFields(this->cx);
                     SimpleTokenReader subSub(this->cx);
                     BinKind subKind;
 
                     if (!sub.taggedTuple(subKind, subFields, &subSub)) {
                         return false;
                     }
-
+                    if (subKind == BinKind::binjs_null) {
+                        if (left) {
+                            return false;
+                        }
+                        break;
+                    }
                     if (subKind == BinKind::variable_declaration) {
                         if (!this->parseVariableDeclarationAux(&subSub, subKind, subFields, left)) {
                             return false;
                         }
                     } else /* Parse as pattern */ {
                         if (!this->parsePatternAux(&subSub, subKind, subFields, left)) {
                             return false;
                         }
@@ -1247,16 +1264,18 @@ ASTReader::parseExpression(SimpleTokenRe
     SimpleTokenReader sub(this->cx);
     BinKind kind;
 
     if (!reader->taggedTuple(kind, fields, &sub)) {
         return false;
     }
 
     switch (kind) {
+        case BinKind::binjs_null:
+            return true;
         case BinKind::identifier: {
             Rooted<PropertyName*> id(this->cx);
             for (auto field: fields) {
                 switch (field) {
                     case BinField::name:
                         if (!this->readString(&sub, &id)) {
                             return false;
                         }
@@ -1361,18 +1380,16 @@ ASTReader::parseExpression(SimpleTokenRe
                         return this->raiseError();
                 }
             }
 
             if (!pattern || !flags) {
                 return this->raiseError();
             }
 
-            // FIXME: RegExpFlag flags = tokenStream.currentToken().regExpFlags();
-
             RegExpFlag reflags = NoFlags;
             for (char c: *flags) {
                 if (c == 'g' && !(reflags & GlobalFlag))
                     reflags = RegExpFlag(reflags | GlobalFlag);
                 else if (c == 'i' && !(reflags & IgnoreCaseFlag))
                     reflags = RegExpFlag(reflags | IgnoreCaseFlag);
                 else if (c == 'm' && !(reflags & MultilineFlag))
                     reflags = RegExpFlag(reflags | MultilineFlag);

--- a/js/src/frontend/BinTokenReader.h
+++ b/js/src/frontend/BinTokenReader.h
@@ -13,16 +13,17 @@ using namespace mozilla;
 using namespace JS;
 
 enum class BinKind {
     array_expression,
     assignment_expression,
     assignment_operator,
     binary_expression,
     binary_operator,
+    binjs_null,
     binjs_scope,
     block_statement,
     boolean_literal,
     break_statement,
     call_expression,
     catch_clause,
     conditional_expression,
     continue_statement,