--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -1256,17 +1256,17 @@ ASTReader::parseExpression(SimpleTokenRe
                 }
             }
 
             if (!left || !right) {
                 return this->raiseError();
             }
 
             // FIXME: Instead of std::string, we should use atoms and comparison
-            // between atoms.
+            // between atom ptr.
             // FIXME: We should probably turn associative operations into lists.
             ParseNodeKind pnk = PNK_LIMIT;
             if (op == "==") {
                 pnk = PNK_EQ;
             } else if (op == "!=") {
                 pnk = PNK_NE;
             } else if (op == "===") {
                 pnk = PNK_STRICTEQ;
@@ -1306,25 +1306,94 @@ ASTReader::parseExpression(SimpleTokenRe
                 pnk = PNK_IN;
             } else if (op == "instanceof") {
                 pnk = PNK_INSTANCEOF;
             } else {
                 return this->raiseError();
             }
 
             UniquePtr<ParseNode> list(new_<ListNode>(pnk, JSOP_NOP, TokenPos()));
+            if (!list) {
+                return false;
+            }
             list->makeEmpty();
             list->append(left.release());
             list->append(right.release());
             out = Move(list);
             break;
         }
-        case BinKind::assignment_expression:
-            // FIXME: Implement
-            break;
+        case BinKind::assignment_expression: {
+            UniquePtr<ParseNode> left;
+            UniquePtr<ParseNode> right;
+            std::string op;
+            for (auto field: fields) {
+                switch (field) {
+                    case BinField::left:
+                        if (!this->parseExpression(&sub, left)) {
+                            return false;
+                        }
+                        break;
+                    case BinField::right:
+                        if (!this->parseExpression(&sub, right)) {
+                            return false;
+                        }
+                        break;
+                    case BinField::operator_:
+                        if (!this->readString(&sub, op)) {
+                            return false;
+                        }
+                        break;
+                    default:
+                        return this->raiseError();
+                }
+            }
+
+            if (!left || !right) {
+                return this->raiseError();
+            }
+
+            // FIXME: Instead of std::string, we should use atoms and comparison
+            // between atom ptr.
+            // FIXME: We should probably turn associative operations into lists.
+            ParseNodeKind pnk = PNK_LIMIT;
+            if (op == "=") {
+                pnk = PNK_ASSIGN;
+            } else if (op == "+=") {
+                pnk = PNK_ADDASSIGN;
+            } else if (op == "-=") {
+                pnk = PNK_SUBASSIGN;
+            } else if (op == "*=") {
+                pnk = PNK_MULASSIGN;
+            } else if (op == "/=") {
+                pnk = PNK_DIVASSIGN;
+            } else if (op == "%=") {
+                pnk = PNK_MODASSIGN;
+            } else if (op == "<<=") {
+                pnk = PNK_LSHASSIGN;
+            } else if (op == ">>=") {
+                pnk = PNK_RSHASSIGN;
+            } else if (op == ">>>=") {
+                pnk = PNK_URSHASSIGN;
+            } else if (op == "|=") {
+                pnk = PNK_BITORASSIGN;
+            } else if (op == "^=") {
+                pnk = PNK_BITXORASSIGN;
+            } else if (op == "&=") {
+                pnk = PNK_BITANDASSIGN;
+            } else {
+                return this->raiseError();
+            }
+
+            UniquePtr<ParseNode> list(new_<BinaryNode>(pnk, JSOP_NOP, TokenPos(), left.get(), right.get()));
+            if (!list) {
+                return false;
+            }
+            Unused << left.release();
+            Unused << right.release();
+        }
         case BinKind::logical_expression:
             // FIXME: Implement
             break;
         case BinKind::member_expression:
             // FIXME: Implement
             break;
         case BinKind::conditional_expression:
             // FIXME: Implement