@@ -43,10 +43,6 @@ class FlowAnalysis<Statement, Expression, Element, Type> {
   final _ElementSet<Element> _emptySet;
   final _State<Element, Type> _identity;
 
-  /// The output list of variables that were read before they were written.
-  /// TODO(scheglov) use _ElementSet?
-  final List<Element> readBeforeWritten = [];
-
   /// The [NodeOperations], used to manipulate expressions.
   final NodeOperations<Expression> nodeOperations;
 
@@ -359,6 +355,11 @@ class FlowAnalysis<Statement, Expression, Element, Type> {
     _current = trueCondition;
   }
 
+  /// Return whether the [variable] is definitely assigned in the current state.
+  bool isAssigned(Element variable) {
+    return !_current.notAssigned.contains(variable);
+  }
+
   void isExpression_end(
       Expression isExpression, Element variable, bool isNot, Type type) {
     if (functionBody.isPotentiallyMutatedInClosure(variable)) {
@@ -459,20 +460,6 @@ class FlowAnalysis<Statement, Expression, Element, Type> {
     return _current.promoted[variable];
   }
 
-  /// Register read of the given [variable] in the current state.
-  void read(Element variable) {
-    if (_current.notAssigned.contains(variable)) {
-      // Add to the list of violating variables, if not there yet.
-      for (var i = 0; i < readBeforeWritten.length; ++i) {
-        var violatingVariable = readBeforeWritten[i];
-        if (identical(violatingVariable, variable)) {
-          return;
-        }
-      }
-      readBeforeWritten.add(variable);
-    }
-  }
-
   /// The [notPromoted] set contains all variables that are potentially
   /// assigned in other cases that might target this with `continue`, so
   /// these variables might have different types and are "un-promoted" from
 
@@ -4,7 +4,6 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
-import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ -23,7 +22,7 @@ class FlowAnalysisHelper {
   final NodeOperations<Expression> _nodeOperations;
 
   /// The reused instance for creating new [FlowAnalysis] instances.
-  final TypeOperations<VariableElement, DartType> _typeOperations;
+  final _TypeSystemTypeOperations _typeOperations;
 
   /// Precomputed sets of potentially assigned variables.
   final AssignedVariables<Statement, VariableElement> assignedVariables;
@@ -58,23 +57,14 @@ class FlowAnalysisHelper {
 
     var left = node.leftHandSide;
 
-    VariableElement localElement;
     if (left is SimpleIdentifier) {
       var element = left.staticElement;
       if (element is VariableElement) {
-        localElement = element;
+        return element;
       }
     }
 
-    // Not assignment to a local variable.
-    if (localElement == null) return null;
-
-    var isCompound = node.operator.type != TokenType.EQ;
-    if (isCompound) {
-      flow.read(localElement);
-    }
-
-    return localElement;
+    return null;
   }
 
   void assignmentExpression_afterRight(
@@ -165,11 +155,6 @@ class FlowAnalysisHelper {
       return;
     }
 
-    for (var variable in flow.readBeforeWritten) {
-      assert(variable is LocalVariableElement);
-      result.readBeforeWritten.add(variable);
-    }
-
     if (!flow.isReachable) {
       result.functionBodiesThatDontComplete.add(node);
     }
@@ -235,17 +220,32 @@ class FlowAnalysisHelper {
     }
   }
 
+  bool isPotentiallyNonNullableLocalReadBeforeWrite(SimpleIdentifier node) {
+    if (flow == null) return false;
+
+    if (node.inDeclarationContext()) return false;
+    if (!node.inGetterContext()) return false;
+
+    var element = node.staticElement;
+    if (element is LocalVariableElement) {
+      if (element.isLate) return false;
+
+      var typeSystem = _typeOperations.typeSystem;
+      if (typeSystem.isPotentiallyNonNullable(element.type)) {
+        return !flow.isAssigned(element);
+      }
+    }
+
+    return false;
+  }
+
   void simpleIdentifier(SimpleIdentifier node) {
     if (flow == null) return;
 
     var element = node.staticElement;
     var isLocalVariable = element is LocalVariableElement;
     if (isLocalVariable || element is ParameterElement) {
       if (node.inGetterContext() && !node.inDeclarationContext()) {
-        if (isLocalVariable) {
-          flow.read(element);
-        }
-
         if (flow.isNullable(element)) {
           result.nullableNodes.add(node);
         }
@@ -334,8 +334,6 @@ class FlowAnalysisHelper {
 class FlowAnalysisResult {
   static const _astKey = 'FlowAnalysisResult';
 
-  final List<LocalVariableElement> readBeforeWritten = [];
-
   /// The list of identifiers, resolved to a local variable or a parameter,
   /// where the variable is known to be nullable.
   final List<SimpleIdentifier> nullableNodes = [];
 
@@ -1446,7 +1446,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   @override
   void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     _checkForFinalNotInitialized(node.variables);
-    _checkForNotAssignedPotentiallyNonNullableLocalVariable(node.variables);
     super.visitVariableDeclarationStatement(node);
   }
 
@@ -4680,45 +4679,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
-  void _checkForNotAssignedPotentiallyNonNullableLocalVariable(
-    VariableDeclarationList node,
-  ) {
-    // Const and final checked separately.
-    if (node.isConst || node.isFinal) {
-      return;
-    }
-
-    if (!_isNonNullable) {
-      return;
-    }
-
-    if (node.isLate) {
-      return;
-    }
-
-    if (node.type == null) {
-      return;
-    }
-    var type = node.type.type;
-
-    if (!_typeSystem.isPotentiallyNonNullable(type)) {
-      return;
-    }
-
-    for (var variable in node.variables) {
-      if (variable.initializer == null &&
-          flowAnalysisResult.readBeforeWritten
-              .contains(variable.declaredElement)) {
-        _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode
-              .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
-          variable.name,
-          [variable.name.name],
-        );
-      }
-    }
-  }
-
   void _checkForNotInitializedNonNullableStaticField(FieldDeclaration node) {
     if (!_isNonNullable) return;
 
 
@@ -5004,6 +5004,17 @@ class ResolverVisitor extends ScopedVisitor {
   @override
   void visitSimpleIdentifier(SimpleIdentifier node) {
     _flowAnalysis?.simpleIdentifier(node);
+
+    if (_flowAnalysis != null &&
+        _flowAnalysis.isPotentiallyNonNullableLocalReadBeforeWrite(node)) {
+      errorReporter.reportErrorForNode(
+        CompileTimeErrorCode
+            .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
+        node,
+        [node.name],
+      );
+    }
+
     super.visitSimpleIdentifier(node);
   }