diff --git a/packages/compiler/src/expression_parser/parser.ts b/packages/compiler/src/expression_parser/parser.ts
index 1decf52d0d9..2284c506d4b 100644
--- a/packages/compiler/src/expression_parser/parser.ts
+++ b/packages/compiler/src/expression_parser/parser.ts
@@ -29,7 +29,6 @@ import {
   ImplicitReceiver,
   Interpolation,
   KeyedRead,
-  KeyedWrite,
   LiteralArray,
   LiteralMap,
   LiteralMapKey,
@@ -40,7 +39,6 @@ import {
   ParseSpan,
   PrefixNot,
   PropertyRead,
-  PropertyWrite,
   RecursiveAstVisitor,
   SafeCall,
   SafeKeyedRead,
@@ -1214,14 +1212,13 @@ class _ParseAST {
       return id;
     });
     const nameSpan = this.sourceSpan(nameStart);
-    let receiver: AST;
 
     if (isSafe) {
       if (this.consumeOptionalOperator('=')) {
         this.error("The '?.' operator cannot be used in the assignment");
-        receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
+        return new EmptyExpr(this.span(start), this.sourceSpan(start));
       } else {
-        receiver = new SafePropertyRead(
+        return new SafePropertyRead(
           this.span(start),
           this.sourceSpan(start),
           nameSpan,
@@ -1235,18 +1232,17 @@ class _ParseAST {
           this.error('Bindings cannot contain assignments');
           return new EmptyExpr(this.span(start), this.sourceSpan(start));
         }
-
-        const value = this.parseConditional();
-        receiver = new PropertyWrite(
+        const receiver = new PropertyRead(
           this.span(start),
           this.sourceSpan(start),
           nameSpan,
           readReceiver,
           id,
-          value,
         );
+        const value = this.parseConditional();
+        return new Binary(this.span(start), this.sourceSpan(start), '=', receiver, value);
       } else {
-        receiver = new PropertyRead(
+        return new PropertyRead(
           this.span(start),
           this.sourceSpan(start),
           nameSpan,
@@ -1255,8 +1251,6 @@ class _ParseAST {
         );
       }
     }
-
-    return receiver;
   }
 
   private parseCall(receiver: AST, start: number, isSafe: boolean): AST {
@@ -1375,8 +1369,14 @@ class _ParseAST {
         if (isSafe) {
           this.error("The '?.' operator cannot be used in the assignment");
         } else {
+          const binaryReceiver = new KeyedRead(
+            this.span(start),
+            this.sourceSpan(start),
+            receiver,
+            key,
+          );
           const value = this.parseConditional();
-          return new KeyedWrite(this.span(start), this.sourceSpan(start), receiver, key, value);
+          return new Binary(this.span(start), this.sourceSpan(start), '=', binaryReceiver, value);
         }
       } else {
         return isSafe
diff --git a/packages/compiler/test/expression_parser/parser_spec.ts b/packages/compiler/test/expression_parser/parser_spec.ts
index ec9857c2373..ca6f135ea44 100644
--- a/packages/compiler/test/expression_parser/parser_spec.ts
+++ b/packages/compiler/test/expression_parser/parser_spec.ts
@@ -532,13 +532,13 @@ describe('parser', () => {
     it('should record property write span', () => {
       const ast = parseAction('a = b');
       expect(unparseWithSpan(ast)).toContain(['a = b', 'a = b']);
-      expect(unparseWithSpan(ast)).toContain(['a = b', '[nameSpan] a']);
+      expect(unparseWithSpan(ast)).toContain(['a', '[nameSpan] a']);
     });
 
     it('should record accessed property write span', () => {
       const ast = parseAction('a.b = c');
       expect(unparseWithSpan(ast)).toContain(['a.b = c', 'a.b = c']);
-      expect(unparseWithSpan(ast)).toContain(['a.b = c', '[nameSpan] b']);
+      expect(unparseWithSpan(ast)).toContain(['a.b', '[nameSpan] b']);
     });
 
     it('should record spans for untagged template literals with no interpolations', () => {