diff --git a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
index e558b4d..dcfb6a0 100644
--- a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
@@ -18,6 +18,7 @@
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/nullable_dereference_verifier.dart';
+import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/task/strong/checker.dart';
 import 'package:meta/meta.dart';
@@ -46,6 +47,10 @@
 
   bool get _isNonNullableByDefault => _typeSystem.isNonNullableByDefault;
 
+  MigrationResolutionHooks get _migrationResolutionHooks {
+    return _resolver.migrationResolutionHooks;
+  }
+
   NullableDereferenceVerifier get _nullableDereferenceVerifier =>
       _resolver.nullableDereferenceVerifier;
 
@@ -57,10 +62,22 @@
     var left = node.leftHandSide;
     var right = node.rightHandSide;
 
+    // Case `id = e`.
+    // Consider an assignment of the form `id = e`, where `id` is an identifier.
+    if (left is SimpleIdentifier) {
+      var leftLookup = _resolver.nameScope.lookup2(left.name);
+      // When the lexical lookup yields a local variable `v`.
+      var leftGetter = leftLookup.getter;
+      if (leftGetter is VariableElement) {
+        _resolve_SimpleIdentifier_LocalVariable(node, left, leftGetter, right);
+        return;
+      }
+    }
+
     left?.accept(_resolver);
     left = node.leftHandSide;
 
-    var leftLocalVariable = _flowAnalysis?.assignmentExpression(node);
+    _flowAnalysis?.assignmentExpression(node);
 
     TokenType operator = node.operator.type;
     if (operator == TokenType.EQ ||
@@ -76,12 +93,7 @@
     _resolve1(node);
     _resolve2(node);
 
-    _flowAnalysis?.assignmentExpression_afterRight(
-        node,
-        leftLocalVariable,
-        operator == TokenType.QUESTION_QUESTION_EQ
-            ? node.rightHandSide.staticType
-            : node.staticType);
+    _flowAnalysis?.assignmentExpression_afterRight(node);
   }
 
   /// Set the static type of [node] to be the least upper bound of the static
@@ -180,6 +192,32 @@
     return type;
   }
 
+  /// Record that the static type of the given node is the given type.
+  ///
+  /// @param expression the node whose type is to be recorded
+  /// @param type the static type of the node
+  ///
+  /// TODO(scheglov) this is duplication
+  void _recordStaticType(Expression expression, DartType type) {
+    if (_resolver.migrationResolutionHooks != null) {
+      // TODO(scheglov) type cannot be null
+      type = _migrationResolutionHooks.modifyExpressionType(
+        expression,
+        type ?? DynamicTypeImpl.instance,
+      );
+    }
+
+    // TODO(scheglov) type cannot be null
+    if (type == null) {
+      expression.staticType = DynamicTypeImpl.instance;
+    } else {
+      expression.staticType = type;
+      if (_typeSystem.isBottom(type)) {
+        _flowAnalysis?.flow?.handleExit();
+      }
+    }
+  }
+
   void _resolve1(AssignmentExpressionImpl node) {
     Token operator = node.operator;
     TokenType operatorType = operator.type;
@@ -290,6 +328,47 @@
     _resolver.nullShortingTermination(node);
   }
 
+  void _resolve_SimpleIdentifier_LocalVariable(
+    AssignmentExpressionImpl node,
+    SimpleIdentifier left,
+    VariableElement leftElement,
+    Expression right,
+  ) {
+    left.staticElement = leftElement;
+
+    var leftType = _resolver.localVariableTypeProvider.getType(left);
+    // TODO(scheglov) Set the type only when `operator != TokenType.EQ`.
+    _recordStaticType(left, leftType);
+
+    var operator = node.operator.type;
+    if (operator != TokenType.EQ) {
+      _resolver.checkReadOfNotAssignedLocalVariable(left);
+    }
+
+    if (operator == TokenType.EQ ||
+        operator == TokenType.QUESTION_QUESTION_EQ) {
+      InferenceContext.setType(right, leftType);
+    }
+
+    var flow = _flowAnalysis?.flow;
+    if (flow != null && operator == TokenType.QUESTION_QUESTION_EQ) {
+      flow.ifNullExpression_rightBegin(left);
+    }
+
+    right?.accept(_resolver);
+    right = node.rightHandSide;
+
+    _resolve1(node);
+    _resolve2(node);
+
+    if (flow != null) {
+      flow.write(leftElement, node.staticType);
+      if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
+        flow.ifNullExpression_end();
+      }
+    }
+  }
+
   /// If the given [type] is a type parameter, resolve it to the type that
   /// should be used when looking up members. Otherwise, return the original
   /// type.
diff --git a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
index f6fe441..96dff00 100644
--- a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
@@ -77,30 +77,16 @@
     flow.asExpression_end(expression, typeAnnotation.type);
   }
 
-  VariableElement assignmentExpression(AssignmentExpression node) {
+  void assignmentExpression(AssignmentExpression node) {
     if (flow == null) return null;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
       flow.ifNullExpression_rightBegin(node.leftHandSide);
     }
-
-    var left = node.leftHandSide;
-
-    if (left is SimpleIdentifier) {
-      var element = left.staticElement;
-      if (element is VariableElement) {
-        return element;
-      }
-    }
-
-    return null;
   }
 
-  void assignmentExpression_afterRight(AssignmentExpression node,
-      VariableElement localElement, DartType writtenType) {
-    if (localElement != null) {
-      flow.write(localElement, writtenType);
-    }
+  void assignmentExpression_afterRight(AssignmentExpression node) {
+    if (flow == null) return null;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
       flow.ifNullExpression_end();
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 8bba9a1..add5879 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -153,6 +153,8 @@
 
   final MigratableAstInfoProvider _migratableAstInfoProvider;
 
+  final MigrationResolutionHooks migrationResolutionHooks;
+
   /// Helper for checking expression that should have the `bool` type.
   BoolExpressionVerifier boolExpressionVerifier;
 
@@ -290,6 +292,7 @@
       this._migratableAstInfoProvider,
       MigrationResolutionHooks migrationResolutionHooks)
       : _featureSet = featureSet,
+        migrationResolutionHooks = migrationResolutionHooks,
         super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     _promoteManager = TypePromotionManager(typeSystem);
@@ -429,6 +432,26 @@
     }
   }
 
+  void checkReadOfNotAssignedLocalVariable(SimpleIdentifier node) {
+    if (_flowAnalysis != null) {
+      if (_flowAnalysis.isPotentiallyNonNullableLocalReadBeforeWrite(node)) {
+        errorReporter.reportErrorForNode(
+          CompileTimeErrorCode
+              .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
+          node,
+          [node.name],
+        );
+      }
+      if (_flowAnalysis.isReadOfDefinitelyUnassignedLateLocal(node)) {
+        errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.DEFINITELY_UNASSIGNED_LATE_LOCAL_VARIABLE,
+          node,
+          [node.name],
+        );
+      }
+    }
+  }
+
   void checkUnreachableNode(AstNode node) {
     nullSafetyDeadCodeVerifier.visitNode(node);
   }
@@ -1533,23 +1556,7 @@
       return;
     }
 
-    if (_flowAnalysis != null) {
-      if (_flowAnalysis.isPotentiallyNonNullableLocalReadBeforeWrite(node)) {
-        errorReporter.reportErrorForNode(
-          CompileTimeErrorCode
-              .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
-          node,
-          [node.name],
-        );
-      }
-      if (_flowAnalysis.isReadOfDefinitelyUnassignedLateLocal(node)) {
-        errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.DEFINITELY_UNASSIGNED_LATE_LOCAL_VARIABLE,
-          node,
-          [node.name],
-        );
-      }
-    }
+    checkReadOfNotAssignedLocalVariable(node);
 
     super.visitSimpleIdentifier(node);
   }
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
index 4c605a3..2ccef51 100644
--- a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
+++ b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -102,14 +102,20 @@
   ///
   /// @param expression the node whose type is to be recorded
   /// @param type the static type of the node
+  ///
+  /// TODO(scheglov) this is duplication
   void recordStaticType(Expression expression, DartType type) {
     if (_migrationResolutionHooks != null) {
+      // TODO(scheglov) type cannot be null
       type = _migrationResolutionHooks.modifyExpressionType(
-          expression, type ?? _dynamicType);
+        expression,
+        type ?? DynamicTypeImpl.instance,
+      );
     }
 
+    // TODO(scheglov) type cannot be null
     if (type == null) {
-      expression.staticType = _dynamicType;
+      expression.staticType = DynamicTypeImpl.instance;
     } else {
       expression.staticType = type;
       if (_typeSystem.isBottom(type)) {
diff --git a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
index 2761663..7ce888a 100644
--- a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -50,34 +50,6 @@
     assertType(right, 'int');
   }
 
-  test_compound_local() async {
-    await resolveTestCode(r'''
-main() {
-  num v = 0;
-  v += 3;
-}
-''');
-    var assignment = findNode.assignment('v += 3');
-    assertElement(
-      assignment,
-      elementMatcher(
-        numElement.getMethod('+'),
-        isLegacy: isNullSafetySdkAndLegacyLibrary,
-      ),
-    );
-    assertType(assignment, 'num'); // num + int = num
-
-    assertSimpleIdentifier(
-      assignment.leftHandSide,
-      readElement: findElement.localVar('v'),
-      writeElement: findElement.localVar('v'),
-      type: 'num',
-    );
-
-    Expression right = assignment.rightHandSide;
-    assertType(right, 'int');
-  }
-
   test_compound_prefixedIdentifier() async {
     await resolveTestCode(r'''
 main() {
@@ -147,80 +119,6 @@
     assertType(right, 'int');
   }
 
-  test_compound_refineType_int_double() async {
-    await assertErrorsInCode(r'''
-main(int i) {
-  i += 1.2;
-  i -= 1.2;
-  i *= 1.2;
-  i %= 1.2;
-}
-''', [
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 21, 3),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 33, 3),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 45, 3),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 57, 3),
-    ]);
-    assertType(findNode.assignment('+='), 'double');
-    assertType(findNode.assignment('-='), 'double');
-    assertType(findNode.assignment('*='), 'double');
-    assertType(findNode.assignment('%='), 'double');
-  }
-
-  test_compound_refineType_int_int() async {
-    await assertNoErrorsInCode(r'''
-main(int i) {
-  i += 1;
-  i -= 1;
-  i *= 1;
-  i ~/= 1;
-  i %= 1;
-}
-''');
-    assertType(findNode.assignment('+='), 'int');
-    assertType(findNode.assignment('-='), 'int');
-    assertType(findNode.assignment('*='), 'int');
-    assertType(findNode.assignment('~/='), 'int');
-    assertType(findNode.assignment('%='), 'int');
-  }
-
-  test_compoundIfNull_differentTypes() async {
-    await assertErrorsInCode(r'''
-main(double a, int b) {
-  a ??= b;
-}
-''', [
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 32, 1),
-    ]);
-    assertType(findNode.assignment('??='), 'num');
-  }
-
-  test_compoundIfNull_sameTypes() async {
-    await assertNoErrorsInCode(r'''
-main(int a) {
-  a ??= 0;
-}
-''');
-    assertType(findNode.assignment('??='), 'int');
-  }
-
-  test_in_const_context() async {
-    await resolveTestCode('''
-void f(num x, int y) {
-  const [x = y];
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x =');
-    assertElement(xRef, findElement.parameter('x'));
-    assertType(xRef, 'num');
-
-    var yRef = findNode.simple('y]');
-    assertElement(yRef, findElement.parameter('y'));
-    assertType(yRef, 'int');
-  }
-
   test_indexExpression_cascade() async {
     await resolveTestCode(r'''
 main() {
@@ -270,25 +168,6 @@
     assertType(assignment, 'double');
   }
 
-  test_nullAware_local() async {
-    await resolveTestCode(r'''
-main() {
-  String v;
-  v ??= 'test';
-}
-''');
-    var assignment = findNode.assignment('v ??=');
-    assertElementNull(assignment);
-    assertType(assignment, 'String');
-
-    SimpleIdentifier left = assignment.leftHandSide;
-    assertElement(left, findElement.localVar('v'));
-    assertType(left, 'String');
-
-    Expression right = assignment.rightHandSide;
-    assertType(right, 'String');
-  }
-
   test_propertyAccess_forwardingStub() async {
     await resolveTestCode(r'''
 class A {
@@ -347,49 +226,6 @@
     assertType(right, 'int');
   }
 
-  test_simple_instanceField_unqualified() async {
-    await resolveTestCode(r'''
-class C {
-  num f = 0;
-  foo() {
-    f = 2;
-  }
-}
-''');
-    var assignment = findNode.assignment('f = 2;');
-    assertElementNull(assignment);
-    assertType(assignment, 'int');
-
-    SimpleIdentifier left = assignment.leftHandSide;
-    assertElement(left, findElement.setter('f'));
-    assertType(left, 'num');
-
-    Expression right = assignment.rightHandSide;
-    assertType(right, 'int');
-  }
-
-  test_simple_local() async {
-    await resolveTestCode(r'''
-main() {
-  num v = 0;
-  v = 2;
-}
-''');
-    var assignment = findNode.assignment('v = 2;');
-    assertElementNull(assignment);
-    assertType(assignment, 'int');
-
-    assertSimpleIdentifier(
-      assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.localVar('v'),
-      type: 'num',
-    );
-
-    Expression right = assignment.rightHandSide;
-    assertType(right, 'int');
-  }
-
   test_simple_prefixedIdentifier() async {
     await resolveTestCode(r'''
 main() {
@@ -543,68 +379,628 @@
     assertType(right, 'int');
   }
 
-  test_simple_staticField_unqualified() async {
-    await resolveTestCode(r'''
-class C {
-  static num f = 0;
-  foo() {
-    f = 2;
-  }
-}
-''');
-    var assignment = findNode.assignment('f = 2');
-    assertElementNull(assignment);
-    assertType(assignment, 'int');
-
-    assertSimpleIdentifier(
-      assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.setter('f'),
-      type: 'num',
-    );
-
-    var right = assignment.rightHandSide;
-    assertType(right, 'int');
-  }
-
-  test_simple_topLevelVariable() async {
-    await resolveTestCode(r'''
-main() {
-  v = 2;
-}
-num v = 0;
-''');
-    var assignment = findNode.assignment('v = 2');
-    assertElementNull(assignment);
-    assertType(assignment, 'int');
-
-    assertSimpleIdentifier(
-      assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topSet('v'),
-      type: 'num',
-    );
-
-    var right = assignment.rightHandSide;
-    assertType(right, 'int');
-  }
-
-  test_to_class() async {
-    await resolveTestCode('''
+  test_simpleIdentifier_class_simple() async {
+    await assertErrorsInCode('''
 class C {}
-void f(int x) {
-  C = x;
+
+void f() {
+  C = 0;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_TYPE, 25, 1),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 29, 1),
+    ]);
+
+    var assignment = findNode.assignment('C = 0');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.class_('C'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_fieldInstance_simple() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  num x = 0;
+
+  void f() {
+    x = 2;
+  }
 }
 ''');
-    expect(result.errors, isNotEmpty);
 
-    var cRef = findNode.simple('C =');
-    assertElement(cRef, findElement.class_('C'));
-    assertType(cRef, 'Type');
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
 
-    var xRef = findNode.simple('x;');
-    assertElement(xRef, findElement.parameter('x'));
-    assertType(xRef, 'int');
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.setter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_fieldStatic_simple() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  static num x = 0;
+
+  void f() {
+    x = 2;
+  }
+}
+''');
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.setter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_getterInstance_simple() async {
+    await assertErrorsInCode('''
+class C {
+  num get x => 0;
+
+  void f() {
+    x = 2;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_NO_SETTER, 46, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.getter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_getterStatic_simple() async {
+    await assertErrorsInCode('''
+class C {
+  static num get x => 0;
+
+  void f() {
+    x = 2;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_NO_SETTER, 53, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.getter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_getterTopLevel_simple() async {
+    await assertErrorsInCode('''
+int get x => 0;
+
+void f() {
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_LOCAL, 30, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.topGet('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_importPrefix_simple() async {
+    await assertErrorsInCode('''
+import 'dart:math' as x;
+
+main() {
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT, 37, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.prefix('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_localVariable_compound() async {
+    await assertNoErrorsInCode(r'''
+void f() {
+  // ignore:unused_local_variable
+  num x = 0;
+  x += 3;
+}
+''');
+
+    var assignment = findNode.assignment('x += 3');
+    assertAssignment(
+      assignment,
+      operatorElement: elementMatcher(
+        numElement.getMethod('+'),
+        isLegacy: isNullSafetySdkAndLegacyLibrary,
+      ),
+      type: 'num', // num + int = num
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: findElement.localVar('x'),
+      writeElement: findElement.localVar('x'),
+      type: 'num',
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_localVariable_simple() async {
+    await assertNoErrorsInCode(r'''
+void f() {
+  // ignore:unused_local_variable
+  num x = 0;
+  x = 2;
+}
+''');
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.localVar('x'),
+      type: 'num',
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_localVariableConst_simple() async {
+    await assertErrorsInCode('''
+void f() {
+  // ignore:unused_local_variable
+  const num x = 1;
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_CONST, 66, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.localVar('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_localVariableFinal_simple() async {
+    await assertErrorsInCode('''
+void f() {
+  // ignore:unused_local_variable
+  final num x = 1;
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_LOCAL, 66, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.localVar('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_parameter_compound_ifNull() async {
+    await assertNoErrorsInCode(r'''
+void f(num x) {
+  x ??= 0;
+}
+''');
+
+    var assignment = findNode.assignment('x ??=');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'num',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: findElement.parameter('x'),
+      writeElement: findElement.parameter('x'),
+      type: 'num',
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_parameter_compound_ifNull_notAssignableType() async {
+    await assertErrorsInCode(r'''
+void f(double a, int b) {
+  a ??= b;
+}
+''', [
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 34, 1),
+    ]);
+
+    var assignment = findNode.assignment('a ??=');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'num',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: findElement.parameter('a'),
+      writeElement: findElement.parameter('a'),
+      type: 'double',
+    );
+
+    assertSimpleIdentifier(
+      assignment.rightHandSide,
+      readElement: findElement.parameter('b'),
+      writeElement: null,
+      type: 'int',
+    );
+  }
+
+  test_simpleIdentifier_parameter_compound_refineType_int_double() async {
+    await assertErrorsInCode(r'''
+void f(int x) {
+  x += 1.2;
+  x -= 1.2;
+  x *= 1.2;
+  x %= 1.2;
+}
+''', [
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 23, 3),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 35, 3),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 47, 3),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 59, 3),
+    ]);
+    assertType(findNode.assignment('+='), 'double');
+    assertType(findNode.assignment('-='), 'double');
+    assertType(findNode.assignment('*='), 'double');
+    assertType(findNode.assignment('%='), 'double');
+  }
+
+  test_simpleIdentifier_parameter_compound_refineType_int_int() async {
+    await assertNoErrorsInCode(r'''
+main(int x) {
+  x += 1;
+  x -= 1;
+  x *= 1;
+  x ~/= 1;
+  x %= 1;
+}
+''');
+    assertType(findNode.assignment('+='), 'int');
+    assertType(findNode.assignment('-='), 'int');
+    assertType(findNode.assignment('*='), 'int');
+    assertType(findNode.assignment('~/='), 'int');
+    assertType(findNode.assignment('%='), 'int');
+  }
+
+  test_simpleIdentifier_parameter_simple() async {
+    await assertNoErrorsInCode(r'''
+void f(num x) {
+  x = 2;
+}
+''');
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.parameter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_parameter_simple_notAssignableType() async {
+    await assertErrorsInCode(r'''
+void f(int x) {
+  x = true;
+}
+''', [
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 22, 4),
+    ]);
+
+    var assignment = findNode.assignment('x = true');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'bool',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.parameter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'bool');
+  }
+
+  test_simpleIdentifier_parameterFinal_simple() async {
+    await assertErrorsInCode('''
+void f(final int x) {
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_LOCAL, 24, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.parameter('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_synthetic_simple() async {
+    await assertErrorsInCode('''
+void f(int y) {
+  = y;
+}
+''', [
+      error(ParserErrorCode.MISSING_IDENTIFIER, 18, 1),
+    ]);
+
+    var assignment = findNode.assignment('= y');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: null,
+      type: 'dynamic',
+    );
+
+    assertSimpleIdentifier(
+      assignment.rightHandSide,
+      readElement: findElement.parameter('y'),
+      writeElement: null,
+      type: 'int',
+    );
+  }
+
+  test_simpleIdentifier_topLevelVariable_simple() async {
+    await assertNoErrorsInCode(r'''
+num x = 0;
+
+void f() {
+  x = 2;
+}
+''');
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.topSet('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_topLevelVariable_simple_notAssignableType() async {
+    await assertErrorsInCode(r'''
+int x = 0;
+
+void f() {
+  x = true;
+}
+''', [
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 29, 4),
+    ]);
+
+    var assignment = findNode.assignment('x = true');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'bool',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.topSet('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'bool');
+  }
+
+  test_simpleIdentifier_topLevelVariableFinal_simple() async {
+    await assertErrorsInCode(r'''
+final num x = 0;
+
+void f() {
+  x = 2;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL_LOCAL, 31, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = 2');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: findElement.topGet('x'),
+      type: null,
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+
+  test_simpleIdentifier_unresolved_simple() async {
+    await assertErrorsInCode(r'''
+void f(int a) {
+  x = a;
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_IDENTIFIER, 18, 1),
+    ]);
+
+    var assignment = findNode.assignment('x = a');
+    assertAssignment(
+      assignment,
+      operatorElement: null,
+      type: 'int',
+    );
+
+    assertSimpleIdentifier(
+      assignment.leftHandSide,
+      readElement: null,
+      writeElement: null,
+      type: null,
+    );
+
+    assertSimpleIdentifier(
+      assignment.rightHandSide,
+      readElement: findElement.parameter('a'),
+      writeElement: null,
+      type: 'int',
+    );
   }
 
   test_to_class_ambiguous() async {
@@ -624,33 +1020,6 @@
     assertType(xRef, 'int');
   }
 
-  test_to_final_parameter() async {
-    await resolveTestCode('''
-f(final int x) {
-  x += 2;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x +=');
-    assertElement(xRef, findElement.parameter('x'));
-    assertType(xRef, 'int');
-  }
-
-  test_to_final_variable_local() async {
-    await resolveTestCode('''
-main() {
-  final x = 1;
-  x += 2;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x +=');
-    assertElement(xRef, findElement.localVar('x'));
-    assertType(xRef, 'int');
-  }
-
   test_to_getter_instance_direct() async {
     await resolveTestCode('''
 class C {
@@ -667,22 +1036,6 @@
     assertType(xRef, 'int');
   }
 
-  test_to_getter_instance_via_implicit_this() async {
-    await resolveTestCode('''
-class C {
-  int get x => 0;
-  f() {
-    x += 2;
-  }
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x +=');
-    assertElement(xRef, findElement.getter('x'));
-    assertType(xRef, 'int');
-  }
-
   test_to_getter_static_direct() async {
     await resolveTestCode('''
 class C {
@@ -699,36 +1052,6 @@
     assertType(xRef, 'int');
   }
 
-  test_to_getter_static_via_scope() async {
-    await resolveTestCode('''
-class C {
-  static int get x => 0;
-  f() {
-    x += 2;
-  }
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x +=');
-    assertElement(xRef, findElement.getter('x'));
-    assertType(xRef, 'int');
-  }
-
-  test_to_getter_top_level() async {
-    await resolveTestCode('''
-int get x => 0;
-main() {
-  x += 2;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x +=');
-    assertElement(xRef, findElement.topGet('x'));
-    assertType(xRef, 'int');
-  }
-
   test_to_non_lvalue() async {
     await resolveTestCode('''
 void f(int x, double y, String z) {
@@ -801,23 +1124,6 @@
     assertType(yRef, 'int');
   }
 
-  test_to_prefix() async {
-    newFile('/test/lib/a.dart', content: '''
-var x = 0;
-''');
-    await resolveTestCode('''
-import 'a.dart' as p;
-main() {
-  p += 2;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var pRef = findNode.simple('p +=');
-    assertElement(pRef, findElement.prefix('p'));
-    assertTypeDynamic(pRef);
-  }
-
   test_to_prefix_increment() async {
     await resolveTestCode('''
 void f(num x, int y) {
@@ -869,60 +1175,6 @@
     assertType(yRef, 'int');
   }
 
-  test_types_local() async {
-    await resolveTestCode(r'''
-int a;
-bool b;
-main() {
-  a = b;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var assignment = findNode.assignment('a = b');
-    assertElementNull(assignment);
-    assertType(assignment, 'bool');
-
-    assertIdentifierTopSetRef(assignment.leftHandSide, 'a');
-    assertIdentifierTopGetRef(assignment.rightHandSide, 'b');
-  }
-
-  test_types_top() async {
-    await resolveTestCode(r'''
-int a = 0;
-bool b = a;
-''');
-    expect(result.errors, isNotEmpty);
-
-    var bDeclaration = findNode.variableDeclaration('b =');
-    TopLevelVariableElement bElement = bDeclaration.declaredElement;
-    assertElement(bDeclaration.name, findElement.topVar('b'));
-    assertTypeNull(bDeclaration.name);
-    assertType(bElement.type, 'bool');
-
-    SimpleIdentifier aRef = bDeclaration.initializer;
-    assertElement(aRef, findElement.topGet('a'));
-    assertType(aRef, 'int');
-  }
-
-  test_types_top_const() async {
-    await resolveTestCode(r'''
-const int a = 0;
-const bool b = a;
-''');
-    expect(result.errors, isNotEmpty);
-
-    var bDeclaration = findNode.variableDeclaration('b =');
-    TopLevelVariableElement bElement = bDeclaration.declaredElement;
-    assertElement(bDeclaration.name, bElement);
-    assertTypeNull(bDeclaration.name);
-    assertType(bElement.type, 'bool');
-
-    SimpleIdentifier aRef = bDeclaration.initializer;
-    assertElement(aRef, findElement.topGet('a'));
-    assertType(aRef, 'int');
-  }
-
   test_unresolved_left_identifier_compound() async {
     await resolveTestCode(r'''
 int b;
@@ -943,26 +1195,6 @@
     assertType(assignment.rightHandSide, 'int');
   }
 
-  test_unresolved_left_identifier_simple() async {
-    await resolveTestCode(r'''
-int b;
-main() {
-  a = b;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var assignment = findNode.assignment('a = b');
-    assertElementNull(assignment);
-    assertType(assignment, 'int');
-
-    assertElementNull(assignment.leftHandSide);
-    assertTypeDynamic(assignment.leftHandSide);
-
-    assertElement(assignment.rightHandSide, findElement.topGet('b'));
-    assertType(assignment.rightHandSide, 'int');
-  }
-
   test_unresolved_left_indexed1_simple() async {
     await resolveTestCode(r'''
 int c;
@@ -1238,32 +1470,4 @@
     assertElement(assignment.rightHandSide, findElement.topGet('d'));
     assertType(assignment.rightHandSide, 'int');
   }
-
-  test_with_synthetic_lhs() async {
-    await resolveTestCode('''
-void f(int x) {
-  = x;
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x;');
-    assertElement(xRef, findElement.parameter('x'));
-    assertType(xRef, 'int');
-  }
-
-  test_with_synthetic_lhs_in_method() async {
-    await resolveTestCode('''
-class C {
-  void f(int x) {
-    = x;
-  }
-}
-''');
-    expect(result.errors, isNotEmpty);
-
-    var xRef = findNode.simple('x;');
-    assertElement(xRef, findElement.parameter('x'));
-    assertType(xRef, 'int');
-  }
 }
diff --git a/tools/VERSION b/tools/VERSION
index 27730e4..ce12337 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 10
 PATCH 0
-PRERELEASE 32
+PRERELEASE 33
 PRERELEASE_PATCH 0
\ No newline at end of file