diff --git a/pkg/analyzer/lib/src/dart/resolver/definite_assignment.dart b/pkg/analyzer/lib/src/dart/resolver/definite_assignment.dart
new file mode 100644
index 0000000..0b1cd1d
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/resolver/definite_assignment.dart
@@ -0,0 +1,793 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// 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:meta/meta.dart';
+
+/// Object that tracks "assigned" status for local variables in a function body.
+///
+/// The client should create a new instance of tracker for a function body.
+///
+/// Each declared local variable must be added using [add].  If the variable
+/// is assigned at the declaration, it is not actually tracked.
+///
+/// For each read of a local variable [read] should be invoked, and for each
+/// write - [write].  If there is a  "read" of a variable before it is
+/// definitely written, the variable is added to output [readBeforeWritten].
+///
+/// For each AST node that affects definite assignment the client must invoke
+/// corresponding `beginX` and `endX` methods.  They will combine assignment
+/// facts registered in parts of AST. These invocations are expected to be
+/// performed as a part of the resolution pass over the AST.
+///
+/// In the examples below, Dart code is listed on the left, and the set of
+/// calls that need to be made to [DefiniteAssignmentTracker] are listed on
+/// the right.
+///
+///
+/// --------------------------------------------------
+/// Assignments.
+///
+/// When the LHS is a local variable, and the assignment is pure, i.e. uses
+/// operators `=` and `??=`, only the RHS is executed, and then the
+/// variable on the LHS is marked as definitely assigned.
+///
+/// ```dart
+/// int V1;      // add(V1)
+/// int V2;      // add(V2)
+/// V1 = 0;      // write(V1)
+/// V2 = V2;     // read(V2) => readBeforeWritten; write(V2)
+/// V1;          // read(V1) => OK
+/// V2;          // read(V2) => readBeforeWritten (already)
+/// ```
+///
+/// In compound assignments to a local variable, or assignments where the LHS
+/// is not a simple identifier, the LHS is executed first, and then the RHS.
+///
+/// ```dart
+/// int V1;                 // add(V1)
+/// List<int> V2;           // add(V2)
+/// V1 += 1;                // read(V1) => readBeforeWritten; write(V1)
+/// V2[0] = (V2 = [0])[0];  // read(V2) => readBeforeWritten; write(V2)
+/// V1;                     // read(V1) => readBeforeWritten (already)
+/// V2;                     // read(V2) => readBeforeWritten (already)
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Logical expression.
+///
+/// In logical expressions `a && b` or `a || b` only `a` is always executed,
+/// in the enclosing branch.  The expression `b` might not be executed, so its
+/// results are on the exit from the logical expression.
+///
+/// ```dart
+/// int V1;      // add(V1)
+/// int V2;      // add(V2)
+/// (
+///   V1 = 1     // write(V1)
+/// ) > 0
+/// &&           // beginBinaryExpressionLogicalRight()
+/// (
+///   V2 = V1    // read(V1) => OK; write(V2)
+/// ) > 0
+/// ;            // endBinaryExpressionLogicalRight()
+/// V1;          // read(V1) => OK
+/// V2;          // read(V2) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// assert(C, M)
+///
+/// The `assert` statement is not guaranteed to execute, so assignments in the
+/// condition and the message are discarded.  But assignments in the condition
+/// are visible in the message.
+///
+/// ```dart
+/// bool V;    // add(V)
+/// assert(    // beginAssertStatement()
+///   V        // read(V) => readBeforeWritten
+/// );         // endAssertExpression()
+/// V          // read(V) => readBeforeWritten
+/// ```
+///
+/// ```dart
+/// bool V;      // add(V)
+/// assert(      // beginAssertExpression()
+///   V = true,  // write(V)
+///   "$V",      // read(V) => OK
+/// );           // endAssertExpression()
+/// V            // read(V) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// if (E) {} else {}
+///
+/// The variable must be assigned in the `then` branch, and the `else` branch.
+///
+/// The condition `E` contributes into the current branch.
+///
+/// ```dart
+/// int V1;     // add(V1)
+/// int V2;     // add(V2)
+/// int V3;     // add(V3)
+/// if (E)
+/// {           // beginIfStatementThen()
+///   V1 = 0;   // write(V1)
+///   V2 = 0;   // write(V2)
+///   V1;       // read(V1) => OK
+///   V2;       // read(V2) => OK
+/// } else {    // beginIfStatementElse()
+///   V1 = 0;   // write(V1)
+///   V3 = 0;   // write(V3)
+///   V1;       // read(V1) => OK
+///   V3;       // read(V3) => OK
+/// }           // endIfStatement(hasElse: true)
+/// V1;         // read(V1) => OK
+/// V2;         // read(V2) => readBeforeWritten
+/// V3;         // read(V3) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// while (E) {}
+///
+/// If `E` is not the `true` literal, which is covered below, then the body of
+/// the loop might be not executed at all.  So, the fork is discarded.
+///
+/// The condition `E` contributes into the current branch.
+///
+/// ```dart
+/// int V;      // add(V)
+/// while (     // beginWhileStatement(labels: [])
+///   E
+/// ) {         // beginWhileStatementBody(isTrue: false)
+///   V = 0;    // write(V)
+///   V;        // read(V) => OK
+/// }           // endWhileStatement()
+/// V;          // read(V) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// while (true) { ...break... }
+///
+/// Statements `break` and `continue` in loops make the rest of the enclosing
+/// (or labelled) loop ineligible for marking variables definitely assigned
+/// outside of the loop. However it is still OK to mark variables assigned and
+/// use their values in the rest of the loop.
+///
+/// ```dart
+/// int V;
+/// while (             // beginWhileStatement(labels: [])
+///   true
+/// ) {                 // beginWhileStatementBody(isTrue: true)
+///   if (condition) {  // beginIfStatement(hasElse: false)
+///     break;          // handleBreak(while);
+///   }                 // endIfStatement()
+///   V = 0;            // write(V)
+///   V;                // read(V) => OK
+/// }                   // endWhileStatement()
+/// V;                  // read(V) => readBeforeWritten
+/// ```
+///
+/// Nested loops:
+///
+/// ```dart
+/// int V1, V2;
+/// L1: while (         // beginWhileStatement(node)
+///   true
+/// ) {                 // beginWhileStatementBody(isTrue: true)
+///   while (           // beginWhileStatement(labels: [])
+///     true
+///   ) {               // beginWhileStatementBody()
+///     if (C1) {       // beginIfStatement(hasElse: true)
+///       V1 = 0;       // write(V1)
+///     } else {        // beginIfStatementElse()
+///       if (C2) {     // beginIfStatement(hasElse: false)
+///         break L1;   // handleBreak(L1: while)
+///       }             // endIfStatement()
+///       V1 = 0;       // write(V1)
+///     }               // endIfStatement()
+///     V1;             // read(V1) => OK
+///   }                 // endWhileStatement()
+///   V1;               // read(V1) => OK
+///   while (           // beginWhileStatement(node)
+///     true
+///   ) {               // beginWhileStatementBody(isTrue: true)
+///     V2 = 0;         // write(V2)
+///     break;          // handleBreak(while)
+///   }                 // endWhileStatement()
+///   V1;               // read(V1) => OK
+///   V2;               // read(V2) => OK
+/// }                   // endWhileStatement()
+/// V1;                 // read(V1) => readBeforeWritten
+/// V2;                 // read(V2) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// do {} while (E)
+///
+/// The body and the condition always execute, all assignments contribute to
+/// the current branch.  The body is tracked in its own branch, so that if
+/// it has an interruption (`break` or `continue`), we can discard the branch
+/// after or before the condition.
+///
+/// ```dart
+/// int V1;                  // add(V1)
+/// int V2;                  // add(V2)
+/// do {                     // beginDoWhileStatement(node)
+///   V1 = 0;                // write(V1)
+///   V1;                    // read(V1) => OK
+/// } while                  // beginDoWhileStatementCondition()
+///   ((V2 = 0) >= 0)        // write(V2)
+/// ;                        // endDoWhileStatement()
+/// V1;                      // read(V1) => OK
+/// V2;                      // read(V2) => OK
+/// ```
+///
+///
+/// --------------------------------------------------
+/// do { ...break... } while (E)
+///
+/// The `break` statement prevents execution of the rest of the body, and
+/// the condition.  So, the branch ends after the condition.
+///
+/// ```dart
+/// int V1;                  // add(V1)
+/// int V2;                  // add(V2)
+/// int V3;                  // add(V3)
+/// do {                     // beginDoWhileStatement(node)
+///   V1 = 0;                // write(V1)
+///   V1;                    // read(V1) => OK
+///   if (C1) break;         // handleBreak(do)
+///   V2 = 0;                // write(V2)
+///   V2;                    // read(V2) => OK
+/// } while                  // beginDoWhileStatementCondition()
+///   ((V3 = 0) >= 0)        // write(V3)
+/// ;                        // endDoWhileStatement()
+/// V1;                      // read(V1) => OK
+/// V2;                      // read(V2) => readBeforeWritten
+/// V3;                      // read(V3) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// do { ...continue... } while (E)
+///
+/// The `continue` statement prevents execution of the rest of the body, but
+/// the condition is always executed.  So, the branch ends before the condition,
+/// and the condition contributes to the enclosing branch.
+///
+/// ```dart
+/// int V1;                  // add(V1)
+/// int V2;                  // add(V2)
+/// int V3;                  // add(V3)
+/// do {                     // beginDoWhileStatement(node)
+///   V1 = 0;                // write(V1)
+///   V1;                    // read(V1) => OK
+///   if (C1) continue;      // handleContinue(do)
+///   V2 = 0;                // write(V2)
+///   V2;                    // read(V2) => OK
+/// } while                  // beginDoWhileStatementCondition()
+///   ((V3 = 0) >= 0)        // write(V3)
+/// ;                        // endDoWhileStatement()
+/// V1;                      // read(V1) => OK
+/// V2;                      // read(V2) => readBeforeWritten
+/// V3;                      // read(V3) => OK
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Try / catch.
+///
+/// The variable must be assigned in the `try` branch and every `catch` branch.
+///
+/// Note, that an improvement is possible, when some first statements in the
+/// `try` branch can be shown to not throw (e.g. `V = 0;`). We could consider
+/// these statements as definitely executed, so producing definite assignments.
+///
+/// ```dart
+/// int V;        // add(V)
+/// try {         // beginTryStatement()
+///   V = f();    // write(V)
+/// }             // endTryStatementBody()
+/// catch (_) {   // beginTryStatementCatchClause()
+///   V = 0;      // write(V)
+/// }             // endTryStatementCatchClause(); endTryStatementCatchClauses()
+/// V;            // read(V) => OK
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Try / finally.
+///
+/// The `finally` clause is always executed, so it is tracked in the branch
+/// that contains the `try` statement.
+///
+/// Without `catch` clauses the `try` clause is always executed to the end,
+/// so also can be tracked in the branch that contains the `try` statement.
+///
+/// ```dart
+/// int V1;     // add(V1)
+/// int V2;     // add(V2)
+/// try {       // beginTryStatement()
+///   V1 = 0;   // write(V1)
+/// }           // endTryStatementBody(); endTryStatementCatchClauses();
+/// finally {
+///   V2 = 0;   // write(V2)
+/// }
+/// V1;         // read(V1) => OK
+/// V2;         // read(V2) => OK
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Try / catch / finally.
+///
+/// The `finally` clause is always executed, so it is tracked in the branch
+/// that contains the `try` statement.
+///
+/// The `try` and `catch` branches are tracked as without `finally`.
+///
+///
+/// --------------------------------------------------
+/// switch (E) { case E1: ... default: }
+///
+/// The variable must be assigned in every `case` branch and must have the
+/// `default` branch.  If the `default` branch is missing, then the `switch`
+/// does not definitely cover all possible values of `E`, so the variable is
+/// not definitely assigned.
+///
+/// The expression `E` contributes into the current branch.
+///
+/// ```dart
+/// int V;      // add(V)
+/// switch      // beginSwitchStatement()
+/// (E) {       // endSwitchStatementExpression()
+///   case 1:   // beginSwitchStatementMember()
+///     V = 0;  // write(V)
+///     break;  // handleBreak(switch)
+///   default:  // beginSwitchStatementMember()
+///     V = 0;  // write(V); handleBreak(switch)
+/// }           // endSwitchStatement(hasDefault: true)
+/// V;          // read(V) => OK
+/// ```
+///
+/// The presence of a `continue L` statement in switch / case is analyzed in an
+/// approximate way; if a given variable is not written to in all case bodies,
+/// it is considered "not definitely assigned", even though a full basic block
+/// analysis would show that it is definitely assigned.
+///
+/// ```dart
+/// int V;           // add(V)
+/// switch           // beginSwitchStatement()
+/// (E) {            // endSwitchStatementExpression()
+///   L: case 1:     // beginSwitchStatementMember()
+///     V = 0;       // write(V)
+///     break;       // handleBreak(switch)
+///   case 2:        // beginSwitchStatementMember()
+///     continue L;  // handleContinue(switch)
+///   default:       // beginSwitchStatementMember()
+///     V = 0;       // write(V); handleBreak(switch)
+/// }                // endSwitchStatement(hasDefault: true)
+/// V;               // read(V) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// For each.
+///
+/// The iterable might be empty, so the body might be not executed, so writes
+/// in the body are discarded.  But writes in the iterable expressions are
+/// always executed.
+///
+/// ```dart
+/// int V1;     // add(V1)
+/// int V2;     // add(V2)
+/// for (var _ in (V1 = [0, 1, 2]))  // beginForEachStatement(node)
+/// {                                // beginForEachStatementBody()
+///   V2 = 0;                        // write(V1)
+/// }                                // endForEachStatement();
+/// V1;         // read(V1) => OK
+/// V2;         // read(V2) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// For statement.
+///
+/// Very similar to `while` statement.  The initializer and condition parts
+/// are always executed, so contribute to definite assignments.  The body and
+/// updaters might be not executed, so writes in them are discarded.  The
+/// updaters are executed after the body, so writes in the body are visible in
+/// the updaters, correspondingly AST portions should be visited, and
+/// [beginForEachStatementBody] should be before [beginForStatementUpdaters],
+/// and followed with [endForStatement].
+///
+/// ```dart
+/// int V1;     // 1. add(V1)
+/// int V2;     // 2. add(V2)
+/// int V3;     // 3. add(V3)
+/// int V4;     // 4. add(V4)
+/// for (                //  5. beginForStatement(node)
+///   var _ = (V1 = 0);  //  6. write(V1)
+///   (V2 = 0) >= 0;     //  7. write(V2)
+///   V3 = 0             // 10. beginForStatementUpdaters(); write(V3)
+/// ) {                  //  8. beginForStatementBody()
+///   V4 = 0;            //  9. write(V4)
+/// }                    // 11. endForStatement()
+/// V1;         // 12. read(V1) => OK
+/// V2;         // 13. read(V2) => OK
+/// V3;         // 14. read(V3) => readBeforeWritten
+/// V4;         // 15. read(V4) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Function expressions - local functions and closures.
+///
+/// A function expression, e.g. a closure passed as an argument of an
+/// invocation, might be invoked synchronously, asynchronously, or never.
+/// So, all local variables that are read in the function expression must be
+/// definitely assigned, but any writes should be discarded on exit from the
+/// function expression.
+///
+/// ```dart
+/// int V1;     // add(V1)
+/// int V2;     // add(V2)
+/// int V3;     // add(V2)
+/// V1 = 0;     // write(V1)
+/// void f() {  // beginFunctionExpression()
+///   V1;       // read(V1) => OK
+///   V2;       // read(V2) => readBeforeWritten
+///   V3 = 0;   // write(V1)
+/// }           // endFunctionExpression();
+/// V2 = 0;     // write(V2)
+/// f();
+/// V1;         // read(V1) => OK
+/// V2;         // read(V2) => OK
+/// V3;         // read(V3) => readBeforeWritten
+/// ```
+///
+///
+/// --------------------------------------------------
+/// Definite exit.
+///
+/// If a definite exit is reached, e.g. a `return` or a `throw` statement,
+/// then all the variables are vacuously definitely assigned.
+///
+/// ```dart
+/// int V;      // add(V)
+/// if (E) {
+/// {           // beginIfStatementThen()
+///   V = 0;    // write(V)
+/// } else {    // beginIfStatementElse()
+///   return;   // handleExit()
+/// }           // endIfStatement(hasElse: true)
+/// V;          // read(V) => OK
+/// ```
+class DefiniteAssignmentTracker {
+  /// The output list of variables that were read before they were written.
+  final List<LocalVariableElement> readBeforeWritten = [];
+
+  /// The stack of sets of variables that are not definitely assigned.
+  final List<_ElementSet> _stack = [];
+
+  /// The mapping from labeled [Statement]s to the index in the [_stack]
+  /// where the first related element is located.  The number of elements
+  /// is statement specific.
+  final Map<Statement, int> _statementToStackIndex = {};
+
+  /// The current set of variables that are not definitely assigned.
+  _ElementSet _current = _ElementSet.empty;
+
+  @visibleForTesting
+  bool get isRootBranch {
+    return _stack.isEmpty;
+  }
+
+  /// Add a new [variable], which might be already [assigned].
+  void add(LocalVariableElement variable, {bool assigned: false}) {
+    if (!assigned) {
+      _current = _current.add(variable);
+    }
+  }
+
+  void beginAssertStatement() {
+    _stack.add(_current);
+  }
+
+  void beginBinaryExpressionLogicalRight() {
+    _stack.add(_current);
+  }
+
+  void beginConditionalExpressionElse() {
+    var afterCondition = _stack.last;
+    _stack.last = _current; // after then
+    _current = afterCondition;
+  }
+
+  void beginConditionalExpressionThen() {
+    _stack.add(_current); // after condition
+  }
+
+  void beginDoWhileStatement(DoStatement statement) {
+    _statementToStackIndex[statement] = _stack.length;
+    _stack.add(_ElementSet.empty); // break set
+    _stack.add(_ElementSet.empty); // continue set
+  }
+
+  void beginDoWhileStatementCondition() {
+    var continueSet = _stack.removeLast();
+    // If there was a `continue`, use it.
+    // If there was not any, use the current.
+    _current = _current.union(continueSet);
+  }
+
+  void beginForEachStatement(ForEachStatement statement) {
+    // Not strongly necessary, because we discard everything anyway.
+    // Just for consistency, so that `break` is handled without `null`.
+    _statementToStackIndex[statement] = _stack.length;
+  }
+
+  void beginForEachStatementBody() {
+    _stack.add(_current);
+  }
+
+  void beginForStatement(ForStatement statement) {
+    // Not strongly necessary, because we discard everything anyway.
+    // Just for consistency, so that `break` is handled without `null`.
+    _statementToStackIndex[statement] = _stack.length;
+  }
+
+  void beginForStatementBody() {
+    _stack.add(_current); // break set
+    _stack.add(_ElementSet.empty); // continue set
+  }
+
+  void beginForStatementUpdaters() {
+    var continueSet = _stack.last;
+    _current = _current.union(continueSet);
+  }
+
+  void beginFunctionExpression() {
+    _stack.add(_current);
+  }
+
+  void beginIfStatementElse() {
+    var enclosing = _stack.last;
+    _stack.last = _current;
+    _current = enclosing;
+  }
+
+  void beginIfStatementThen() {
+    _stack.add(_current);
+  }
+
+  void beginSwitchStatement(SwitchStatement statement) {
+    _statementToStackIndex[statement] = _stack.length;
+    _stack.add(_ElementSet.empty); // break set
+    _stack.add(_ElementSet.empty); // continue set (placeholder)
+  }
+
+  void beginSwitchStatementMember() {
+    _current = _stack.last; // before cases
+  }
+
+  void beginTryStatement() {
+    _stack.add(_current); // before body, for catches
+  }
+
+  void beginTryStatementCatchClause() {
+    _current = _stack[_stack.length - 2]; // before body
+  }
+
+  void beginWhileStatement(WhileStatement statement) {
+    _statementToStackIndex[statement] = _stack.length;
+  }
+
+  void beginWhileStatementBody(bool isTrue) {
+    _stack.add(isTrue ? _ElementSet.empty : _current); // break set
+    _stack.add(_ElementSet.empty); // continue set
+  }
+
+  void endAssertStatement() {
+    _current = _stack.removeLast();
+  }
+
+  void endBinaryExpressionLogicalRight() {
+    _current = _stack.removeLast();
+  }
+
+  void endConditionalExpression() {
+    var thenSet = _stack.removeLast();
+    var elseSet = _current;
+    _current = thenSet.union(elseSet);
+  }
+
+  void endDoWhileStatement() {
+    var breakSet = _stack.removeLast();
+    // If there was a `break`, use it.
+    // If there was not any, use the current.
+    _current = _current.union(breakSet);
+  }
+
+  void endForEachStatement() {
+    _current = _stack.removeLast();
+  }
+
+  void endForStatement() {
+    _stack.removeLast(); // continue set
+    _current = _stack.removeLast(); // break set, before body
+  }
+
+  void endFunctionExpression() {
+    _current = _stack.removeLast();
+  }
+
+  void endIfStatement(bool hasElse) {
+    if (hasElse) {
+      var thenSet = _stack.removeLast();
+      var elseSet = _current;
+      _current = thenSet.union(elseSet);
+    } else {
+      var afterCondition = _stack.removeLast();
+      _current = afterCondition;
+    }
+  }
+
+  void endSwitchStatement(bool hasDefault) {
+    var beforeCasesSet = _stack.removeLast();
+    _stack.removeLast(); // continue set
+    var breakSet = _stack.removeLast();
+    if (hasDefault) {
+      _current = breakSet;
+    } else {
+      _current = beforeCasesSet;
+    }
+  }
+
+  void endSwitchStatementExpression() {
+    _stack.add(_current); // before cases
+  }
+
+  void endTryStatementBody() {
+    _stack.add(_current); // union of body and catches
+  }
+
+  void endTryStatementCatchClause() {
+    _stack.last = _stack.last.union(_current); // union of body and catches
+  }
+
+  void endTryStatementCatchClauses() {
+    _current = _stack.removeLast(); // union of body and catches
+    _stack.removeLast(); // before body
+  }
+
+  void endWhileStatement() {
+    _stack.removeLast(); // continue set
+    _current = _stack.removeLast(); // break set
+  }
+
+  /// Handle a `break` statement with the given [target].
+  void handleBreak(AstNode target) {
+    var breakSetIndex = _statementToStackIndex[target];
+    if (breakSetIndex != null) {
+      _stack[breakSetIndex] = _stack[breakSetIndex].union(_current);
+    }
+    _current = _ElementSet.empty;
+  }
+
+  /// Handle a `continue` statement with the given [target].
+  void handleContinue(AstNode target) {
+    var breakSetIndex = _statementToStackIndex[target];
+    if (breakSetIndex != null) {
+      var continueSetIndex = breakSetIndex + 1;
+      _stack[continueSetIndex] = _stack[continueSetIndex].union(_current);
+    }
+    _current = _ElementSet.empty;
+  }
+
+  /// Register the fact that the current branch definitely exists, e.g. returns
+  /// from the body, throws an exception, etc.  So, all variables in the branch
+  /// are vacuously definitely assigned.
+  void handleExit() {
+    _current = _ElementSet.empty;
+  }
+
+  /// Register read of the given [variable] in the current branch.
+  void read(LocalVariableElement variable) {
+    if (_current.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);
+    }
+  }
+
+  /// Register write of the given [variable] in the current branch.
+  void write(LocalVariableElement variable) {
+    _current = _current.remove(variable);
+  }
+}
+
+/// List based immutable set of elements.
+class _ElementSet {
+  static final empty = _ElementSet._(
+    List<LocalVariableElement>(0),
+  );
+
+  final List<LocalVariableElement> elements;
+
+  _ElementSet._(this.elements);
+
+  _ElementSet add(LocalVariableElement addedElement) {
+    if (contains(addedElement)) {
+      return this;
+    }
+
+    var length = elements.length;
+    var newElements = List<LocalVariableElement>(length + 1);
+    for (var i = 0; i < length; ++i) {
+      newElements[i] = elements[i];
+    }
+    newElements[length] = addedElement;
+    return _ElementSet._(newElements);
+  }
+
+  bool contains(LocalVariableElement element) {
+    var length = elements.length;
+    for (var i = 0; i < length; ++i) {
+      if (identical(elements[i], element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  _ElementSet remove(LocalVariableElement removedElement) {
+    if (!contains(removedElement)) {
+      return this;
+    }
+
+    var length = elements.length;
+    if (length == 1) {
+      return empty;
+    }
+
+    var newElements = List<LocalVariableElement>(length - 1);
+    var newIndex = 0;
+    for (var i = 0; i < length; ++i) {
+      var element = elements[i];
+      if (!identical(element, removedElement)) {
+        newElements[newIndex++] = element;
+      }
+    }
+
+    return _ElementSet._(newElements);
+  }
+
+  _ElementSet union(_ElementSet other) {
+    if (other == null || other.elements.isEmpty) {
+      return this;
+    }
+
+    var result = this;
+    var otherElements = other.elements;
+    for (var i = 0; i < otherElements.length; ++i) {
+      var otherElement = otherElements[i];
+      result = result.add(otherElement);
+    }
+    return result;
+  }
+}
diff --git a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
index 6bf04e5..a2abdd1 100644
--- a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
@@ -65,7 +65,7 @@
     assertType(assignment, 'num'); // num + int = num
 
     SimpleIdentifier left = assignment.leftHandSide;
-    assertElement(left, findElement.localVar('x'));
+    assertElement(left, findElement.localVar('v'));
     assertType(left, 'num');
 
     Expression right = assignment.rightHandSide;
diff --git a/pkg/analyzer/test/src/dart/resolution/definite_assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/definite_assignment_test.dart
new file mode 100644
index 0000000..c9d840d
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/definite_assignment_test.dart
@@ -0,0 +1,1533 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/dart/ast/ast.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/src/dart/resolver/definite_assignment.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(DefiniteAssignmentTrackerTest);
+  });
+}
+
+@reflectiveTest
+class DefiniteAssignmentTrackerTest extends DriverResolutionTest {
+  DefiniteAssignmentTracker tracker;
+
+  /// Assert that only local variables with the given names are marked as read
+  /// before being written.  All the other local variables are implicitly
+  /// considered definitely assigned.
+  void assertReadBeforeWritten(
+      [String name1, String name2, String name3, String name4]) {
+    var expected = [name1, name2, name3, name4]
+        .where((i) => i != null)
+        .map((name) => findElement.localVar(name))
+        .toList();
+    expect(tracker.readBeforeWritten, unorderedEquals(expected));
+  }
+
+  test_assert() async {
+    await trackCode(r'''
+main() {
+  int v;
+  assert((v = 0) >= 0, v);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftExpression() async {
+    await trackCode(r'''
+main() {
+  List<int> v;
+  v[0] = (v = [1, 2])[1];
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftLocal_compound() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v += 1;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftLocal_compound_assignInRight() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v += (v = v);
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftLocal_pure_eq() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v = 0;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_assignment_leftLocal_pure_eq_self() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v = v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftLocal_pure_questionEq() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v ??= 0;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_assignment_leftLocal_pure_questionEq_self() async {
+    await trackCode(r'''
+main() {
+  int v;
+  v ??= v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_binaryExpression_ifNull_left() async {
+    await trackCode(r'''
+main() {
+  int v;
+  (v = 0) ?? 0;
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_binaryExpression_ifNull_right() async {
+    await trackCode(r'''
+main(int a) {
+  int v;
+  a ?? (v = 0);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_binaryExpression_logicalAnd_left() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  ((v = 0) >= 0) && c;
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_binaryExpression_logicalAnd_right() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  c && ((v = 0) >= 0);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_binaryExpression_logicalOr_left() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  ((v = 0) >= 0) || c;
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_binaryExpression_logicalOr_right() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  c || ((v = 0) >= 0);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_binaryExpression_plus_left() async {
+    await trackCode(r'''
+main() {
+  int v;
+  (v = 0) + 1;
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_binaryExpression_plus_right() async {
+    await trackCode(r'''
+main() {
+  int v;
+  1 + (v = 0);
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_conditionalExpression_both() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  c ? (v = 0) : (v = 0);
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_conditionalExpression_condition() async {
+    await trackCode(r'''
+main() {
+  int v;
+  (v = 0) >= 0 ? 1 : 2;
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_conditionalExpression_else() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  c ? (v = 0) : 2;
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_conditionalExpression_then() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  c ? (v = 0) : 2;
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_doWhile_break_afterAssignment() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  do {
+    v = 0;
+    v;
+    if (c) break;
+  } while (c);
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_doWhile_break_beforeAssignment() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  do {
+    if (c) break;
+    v = 0;
+  } while (c);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_doWhile_breakOuterFromInner() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2, v3;
+  L1: do {
+    do {
+      v1 = 0;
+      if (c) break L1;
+      v2 = 0;
+      v3 = 0;
+    } while (c);
+    v2;
+  } while (c);
+  v1;
+  v3;
+}
+''');
+    assertReadBeforeWritten('v3');
+  }
+
+  test_doWhile_condition() async {
+    await trackCode(r'''
+main() {
+  int v1, v2;
+  do {
+    v1; // assigned in the condition, but not yet
+  } while ((v1 = 0) + (v2 = 0) >= 0);
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1');
+  }
+
+  test_doWhile_condition_break() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  do {
+    if (c) break;
+  } while ((v = 0) >= 0);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_doWhile_condition_break_continue() async {
+    await trackCode(r'''
+main(bool c1, bool c2) {
+  int v1, v2, v3, v4, v5, v6;
+  do {
+    v1 = 0; // visible outside, visible to the condition
+    if (c1) break;
+    v2 = 0; // not visible outside, visible to the condition
+    v3 = 0; // not visible outside, visible to the condition
+    if (c2) continue;
+    v4 = 0; // not visible
+    v5 = 0; // not visible
+  } while ((v6 = v1 + v2 + v4) == 0); // has break => v6 is not visible outside
+  v1;
+  v3;
+  v5;
+  v6;
+}
+''');
+    assertReadBeforeWritten('v3', 'v4', 'v5', 'v6');
+  }
+
+  test_doWhile_condition_continue() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2, v3, v4;
+  do {
+    v1 = 0; // visible outside, visible to the condition
+    if (c) continue;
+    v2 = 0; // not visible
+    v3 = 0; // not visible
+  } while ((v4 = v1 + v2) == 0); // no break => v4 visible outside
+  v1;
+  v3;
+  v4;
+}
+''');
+    assertReadBeforeWritten('v2', 'v3');
+  }
+
+  test_doWhile_continue_beforeAssignment() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  do {
+    if (c) continue;
+    v = 0;
+  } while (c);
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_for_body() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  for (; c;) {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_for_break() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (; c;) {
+    v1 = 0;
+    if (c) break;
+    v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1', 'v2');
+  }
+
+  test_for_break_updaters() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (; c; v1 + v2) {
+    v1 = 0;
+    if (c) break;
+    v2 = 0;
+  }
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_for_condition() async {
+    await trackCode(r'''
+main() {
+  int v;
+  for (; (v = 0) >= 0;) {
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_for_continue() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (; c;) {
+    v1 = 0;
+    if (c) continue;
+    v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1', 'v2');
+  }
+
+  test_for_continue_updaters() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (; c; v1 + v2) {
+    v1 = 0;
+    if (c) continue;
+    v2 = 0;
+  }
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_for_initializer_expression() async {
+    await trackCode(r'''
+main() {
+  int v;
+  for (v = 0;;) {
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_for_initializer_variable() async {
+    await trackCode(r'''
+main() {
+  int v;
+  for (var t = (v = 0);;) {
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_for_updaters() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2, v3, v4;
+  for (; c; v1 = 0, v2 = 0, v3 = 0, v4) {
+    v1;
+  }
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1', 'v2', 'v4');
+  }
+
+  test_for_updaters_afterBody() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  for (; c; v) {
+    v = 0;
+  }
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_forEach() async {
+    await trackCode(r'''
+main() {
+  int v1, v2;
+  for (var _ in (v1 = [0, 1, 2])) {
+    v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_forEach_break() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (var _ in [0, 1, 2]) {
+    v1 = 0;
+    if (c) break;
+    v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1', 'v2');
+  }
+
+  test_forEach_continue() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  for (var _ in [0, 1, 2]) {
+    v1 = 0;
+    if (c) continue;
+    v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v1', 'v2');
+  }
+
+  test_functionExpression_closure_read() async {
+    await trackCode(r'''
+main() {
+  int v1, v2;
+  
+  v1 = 0;
+  
+  [0, 1, 2].forEach((t) {
+    v1;
+    v2;
+  });
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_functionExpression_closure_write() async {
+    await trackCode(r'''
+main() {
+  int v;
+  
+  [0, 1, 2].forEach((t) {
+    v = t;
+  });
+
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_functionExpression_localFunction_local() async {
+    await trackCode(r'''
+main() {
+  int v;
+
+  v = 0;
+
+  void f() {
+    int v; // 1
+    v;
+  }
+}
+''');
+    var localV = findNode.simple('v; // 1').staticElement;
+    expect(tracker.readBeforeWritten, unorderedEquals([localV]));
+  }
+
+  test_functionExpression_localFunction_local2() async {
+    await trackCode(r'''
+main() {
+  int v1;
+
+  v1 = 0;
+
+  void f() {
+    int v2, v3;
+    v2 = 0;
+    v1;
+    v2;
+    v3;
+  }
+}
+''');
+    assertReadBeforeWritten('v3');
+  }
+
+  test_functionExpression_localFunction_read() async {
+    await trackCode(r'''
+main() {
+  int v1, v2, v3;
+
+  v1 = 0;
+
+  void f() {
+    v1;
+    v2;
+  }
+
+  v2 = 0;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_functionExpression_localFunction_write() async {
+    await trackCode(r'''
+main() {
+  int v;
+
+  void f() {
+    v = 0;
+  }
+
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_if_condition() async {
+    await trackCode(r'''
+main() {
+  int v;
+  if ((v = 0) >= 0) {
+    v;
+  } else {
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_if_then() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_if_thenElse_all() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+    v;
+  } else {
+    v = 0;
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_if_thenElse_else() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    // not assigned
+  } else {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_if_thenElse_then() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+  } else {
+    // not assigned
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_if_thenElse_then_exit_alwaysThrows() async {
+    addMetaPackage();
+    await trackCode(r'''
+import 'package:meta/meta.dart';
+
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+  } else {
+    foo();
+  }
+  v;
+}
+
+@alwaysThrows
+void foo() {}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_if_thenElse_then_exit_return() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+  } else {
+    return;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_if_thenElse_then_exit_throw() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  if (c) {
+    v = 0;
+  } else {
+    throw 42;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_switch_case1_default() async {
+    await trackCode(r'''
+main(int e) {
+  int v;
+  switch (e) {
+    case 1:
+      v = 0;
+      break;
+    case 2:
+      // not assigned
+      break;
+    default:
+      v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_switch_case2_default() async {
+    await trackCode(r'''
+main(int e) {
+  int v1, v2;
+  switch (e) {
+    case 1:
+      v1 = 0;
+      v2 = 0;
+      v1;
+      break;
+    default:
+      v1 = 0;
+      v1;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_switch_case_default_break() async {
+    await trackCode(r'''
+main(int e, bool c) {
+  int v1, v2;
+  switch (e) {
+    case 1:
+      v1 = 0;
+      if (c) break;
+      v2 = 0;
+      break;
+    default:
+      v1 = 0;
+      if (c) break;
+      v2 = 0;
+  }
+  v1;
+  v2;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_switch_case_default_continue() async {
+    await trackCode(r'''
+main(int e) {
+  int v;
+  switch (e) {
+    L: case 1:
+      v = 0;
+      break;
+    case 2:
+      continue L;
+    default:
+      v = 0;
+  }
+  v;
+}
+''');
+    // We don't analyze to which `case` we go from `continue L`,
+    // but we don't have to. If all cases assign, then the variable is
+    // not in the `breakSet`. And if there is a case when it is not assigned,
+    // we the variable will be left in the `breakSet`.
+    assertReadBeforeWritten();
+  }
+
+  test_switch_case_noDefault() async {
+    await trackCode(r'''
+main(int e) {
+  int v;
+  switch (e) {
+    case 1:
+      v = 0;
+      break;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_switch_condition() async {
+    await trackCode(r'''
+main() {
+  int v;
+  switch (v = 0) {}
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_tryCatch_all() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    f();
+    v = 0;
+  } catch (_) {
+    v = 0;
+  }
+  v;
+}
+
+void f() {}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_tryCatch_catch() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    // not assigned
+  } catch (_) {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_tryCatch_try() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    v = 0;
+  } catch (_) {
+    // not assigned
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_tryCatchFinally_catch() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    // not assigned
+  } catch (_) {
+    v = 0;
+  } finally {
+    // not assigned
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_tryCatchFinally_finally() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    // not assigned
+  } catch (_) {
+    // not assigned
+  } finally {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_tryCatchFinally_try() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    v = 0;
+  } catch (_) {
+    // not assigned
+  } finally {
+    // not assigned
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten('v');
+  }
+
+  test_tryFinally_finally() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    // not assigned
+  } finally {
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_tryFinally_try() async {
+    await trackCode(r'''
+main() {
+  int v;
+  try {
+    v = 0;
+  } finally {
+    // not assigned
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_condition() async {
+    await trackCode(r'''
+main() {
+  int v;
+  while ((v = 0) >= 0) {
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_condition_notTrue() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  while (c) {
+    v1 = 0;
+    v2 = 0;
+    v1;
+  }
+  v2;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_while_true_break_afterAssignment() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  while (true) {
+    v1 = 0;
+    v1;
+    if (c) break;
+    v1;
+    v2 = 0;
+    v2;
+  }
+  v1;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_true_break_beforeAssignment() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  while (true) {
+    if (c) break;
+    v1 = 0;
+    v2 = 0;
+    v2;
+  }
+  v1;
+}
+''');
+    assertReadBeforeWritten('v1');
+  }
+
+  test_while_true_break_if() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  while (true) {
+    if (c) {
+      v = 0;
+      break;
+    } else {
+      v = 0;
+      break;
+    }
+    v;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_true_break_if2() async {
+    await trackCode(r'''
+main(bool c) {
+  var v;
+  while (true) {
+    if (c) {
+      break;
+    } else {
+      v = 0;
+    }
+    v;
+  }
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_true_break_if3() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2;
+  while (true) {
+    if (c) {
+      v1 = 0;
+      v2 = 0;
+      if (c) break;
+    } else {
+      if (c) break;
+      v1 = 0;
+      v2 = 0;
+    }
+    v1;
+  }
+  v2;
+}
+''');
+    assertReadBeforeWritten('v2');
+  }
+
+  test_while_true_breakOuterFromInner() async {
+    await trackCode(r'''
+main(bool c) {
+  int v1, v2, v3;
+  L1: while (true) {
+    L2: while (true) {
+      v1 = 0;
+      if (c) break L1;
+      v2 = 0;
+      v3 = 0;
+      if (c) break L2;
+    }
+    v2;
+  }
+  v1;
+  v3;
+}
+''');
+    assertReadBeforeWritten('v3');
+  }
+
+  test_while_true_continue() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  while (true) {
+    if (c) continue;
+    v = 0;
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  test_while_true_noBreak() async {
+    await trackCode(r'''
+main(bool c) {
+  int v;
+  while (true) {
+    // No assignment, but not break.
+    // So, we don't exit the loop.
+    // So, all variables are assigned.
+  }
+  v;
+}
+''');
+    assertReadBeforeWritten();
+  }
+
+  /// Resolve the given [code] and track assignments in the unit.
+  Future<void> trackCode(String code) async {
+    addTestFile(code);
+    await resolveTestFile();
+
+    tracker = DefiniteAssignmentTracker();
+
+    var visitor = _AstVisitor(tracker);
+    result.unit.accept(visitor);
+  }
+}
+
+/// [AstVisitor] that drives the [tracker] in the way we expect the resolver
+/// will do in production.
+class _AstVisitor extends RecursiveAstVisitor<void> {
+  final DefiniteAssignmentTracker tracker;
+
+  _AstVisitor(this.tracker);
+
+  @override
+  void visitAssertStatement(AssertStatement node) {
+    tracker.beginAssertStatement();
+    super.visitAssertStatement(node);
+    tracker.endAssertStatement();
+  }
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    var left = node.leftHandSide;
+    var right = node.rightHandSide;
+
+    LocalVariableElement localElement;
+    if (left is SimpleIdentifier) {
+      var element = left.staticElement;
+      if (element is LocalVariableElement) {
+        localElement = element;
+      }
+    }
+
+    if (localElement != null) {
+      var isPure = node.operator.type == TokenType.EQ;
+      if (!isPure) {
+        tracker.read(localElement);
+      }
+      right.accept(this);
+      tracker.write(localElement);
+    } else {
+      left.accept(this);
+      right.accept(this);
+    }
+  }
+
+  @override
+  void visitBinaryExpression(BinaryExpression node) {
+    var left = node.leftOperand;
+    var right = node.rightOperand;
+
+    var operator = node.operator.type;
+    var isLogical = operator == TokenType.AMPERSAND_AMPERSAND ||
+        operator == TokenType.BAR_BAR ||
+        operator == TokenType.QUESTION_QUESTION;
+
+    left.accept(this);
+
+    if (isLogical) {
+      tracker.beginBinaryExpressionLogicalRight();
+    }
+
+    right.accept(this);
+
+    if (isLogical) {
+      tracker.endBinaryExpressionLogicalRight();
+    }
+  }
+
+  @override
+  void visitBreakStatement(BreakStatement node) {
+    var target = _getLabelTarget(node, node.label?.staticElement);
+    tracker.handleBreak(target);
+    super.visitBreakStatement(node);
+  }
+
+  @override
+  void visitConditionalExpression(ConditionalExpression node) {
+    var condition = node.condition;
+    var thenExpression = node.thenExpression;
+    var elseExpression = node.elseExpression;
+
+    condition.accept(this);
+
+    tracker.beginConditionalExpressionThen();
+    thenExpression.accept(this);
+
+    tracker.beginConditionalExpressionElse();
+    elseExpression.accept(this);
+
+    tracker.endConditionalExpression();
+  }
+
+  @override
+  void visitContinueStatement(ContinueStatement node) {
+    var target = _getLabelTarget(node, node.label?.staticElement);
+    tracker.handleContinue(target);
+    super.visitContinueStatement(node);
+  }
+
+  @override
+  void visitDoStatement(DoStatement node) {
+    var body = node.body;
+    var condition = node.condition;
+
+    tracker.beginDoWhileStatement(node);
+    body.accept(this);
+
+    tracker.beginDoWhileStatementCondition();
+    condition.accept(this);
+
+    tracker.endDoWhileStatement();
+  }
+
+  @override
+  void visitForEachStatement(ForEachStatement node) {
+    var iterable = node.iterable;
+    var body = node.body;
+
+    tracker.beginForEachStatement(node);
+    iterable.accept(this);
+
+    tracker.beginForEachStatementBody();
+    body.accept(this);
+
+    tracker.endForEachStatement();
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    var variables = node.variables;
+    var initialization = node.initialization;
+
+    var condition = node.condition;
+    var updaters = node.updaters;
+    var body = node.body;
+
+    tracker.beginForStatement(node);
+
+    variables?.accept(this);
+    initialization?.accept(this);
+    condition?.accept(this);
+
+    tracker.beginForStatementBody();
+    body?.accept(this);
+
+    tracker.beginForStatementUpdaters();
+    updaters?.accept(this);
+
+    tracker.endForStatement();
+  }
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    super.visitFunctionDeclaration(node);
+    if (node.parent is CompilationUnit) {
+      expect(tracker.isRootBranch, isTrue);
+    }
+  }
+
+  @override
+  void visitFunctionExpression(FunctionExpression node) {
+    tracker.beginFunctionExpression();
+    super.visitFunctionExpression(node);
+    tracker.endFunctionExpression();
+  }
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    var condition = node.condition;
+    var thenStatement = node.thenStatement;
+    var elseStatement = node.elseStatement;
+
+    condition.accept(this);
+
+    tracker.beginIfStatementThen();
+    thenStatement.accept(this);
+
+    if (elseStatement != null) {
+      tracker.beginIfStatementElse();
+      elseStatement.accept(this);
+    }
+
+    tracker.endIfStatement(elseStatement != null);
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    super.visitMethodInvocation(node);
+    var element = node.methodName.staticElement;
+    if (element != null && element.hasAlwaysThrows) {
+      tracker.handleExit();
+    }
+  }
+
+  @override
+  void visitReturnStatement(ReturnStatement node) {
+    super.visitReturnStatement(node);
+    tracker.handleExit();
+  }
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    var element = node.staticElement;
+    if (element is LocalVariableElement) {
+      if (node.inGetterContext()) {
+        tracker.read(element);
+      }
+    }
+
+    super.visitSimpleIdentifier(node);
+  }
+
+  @override
+  void visitSwitchStatement(SwitchStatement node) {
+    tracker.beginSwitchStatement(node);
+
+    node.expression.accept(this);
+    tracker.endSwitchStatementExpression();
+
+    var members = node.members;
+    var membersLength = members.length;
+    var hasDefault = false;
+    for (var i = 0; i < membersLength; i++) {
+      var member = members[i];
+      tracker.beginSwitchStatementMember();
+      member.accept(this);
+      // Implicit `break` at the end of `default`.
+      if (member is SwitchDefault) {
+        hasDefault = true;
+        tracker.handleBreak(node);
+      }
+    }
+
+    tracker.endSwitchStatement(hasDefault);
+  }
+
+  @override
+  void visitThrowExpression(ThrowExpression node) {
+    super.visitThrowExpression(node);
+    tracker.handleExit();
+  }
+
+  @override
+  void visitTryStatement(TryStatement node) {
+    var body = node.body;
+    var catchClauses = node.catchClauses;
+
+    tracker.beginTryStatement();
+
+    body.accept(this);
+    tracker.endTryStatementBody();
+
+    var catchLength = catchClauses.length;
+    for (var i = 0; i < catchLength; ++i) {
+      var catchClause = catchClauses[i];
+      tracker.beginTryStatementCatchClause();
+      catchClause.accept(this);
+      tracker.endTryStatementCatchClause();
+    }
+
+    tracker.endTryStatementCatchClauses();
+
+    node.finallyBlock?.accept(this);
+  }
+
+  @override
+  void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    var variables = node.variables.variables;
+    for (var i = 0; i < variables.length; ++i) {
+      var variable = variables[i];
+      tracker.add(variable.declaredElement,
+          assigned: variable.initializer != null);
+    }
+
+    super.visitVariableDeclarationStatement(node);
+  }
+
+  @override
+  void visitWhileStatement(WhileStatement node) {
+    var condition = node.condition;
+    var body = node.body;
+
+    tracker.beginWhileStatement(node);
+    condition.accept(this);
+
+    var conditionIsLiteralTrue = condition is BooleanLiteral && condition.value;
+    tracker.beginWhileStatementBody(conditionIsLiteralTrue);
+    body.accept(this);
+
+    tracker.endWhileStatement();
+  }
+
+  /// This code has OK performance for tests, but think if there is something
+  /// better when using in production.
+  AstNode _getLabelTarget(AstNode node, LabelElement element) {
+    for (; node != null; node = node.parent) {
+      if (node is DoStatement ||
+          node is ForEachStatement ||
+          node is ForStatement ||
+          node is SwitchStatement ||
+          node is WhileStatement) {
+        if (element == null) {
+          return node;
+        }
+        var parent = node.parent;
+        if (parent is LabeledStatement) {
+          for (var nodeLabel in parent.labels) {
+            if (identical(nodeLabel.label.staticElement, element)) {
+              return node;
+            }
+          }
+        }
+      }
+      if (element != null && node is SwitchStatement) {
+        for (var member in node.members) {
+          for (var nodeLabel in member.labels) {
+            if (identical(nodeLabel.label.staticElement, element)) {
+              return node;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
diff --git a/pkg/analyzer/test/src/dart/resolution/driver_resolution.dart b/pkg/analyzer/test/src/dart/resolution/driver_resolution.dart
index dd1137b..081ef0e 100644
--- a/pkg/analyzer/test/src/dart/resolution/driver_resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/driver_resolution.dart
@@ -32,6 +32,14 @@
   /// Override this to change the analysis options for a given set of tests.
   AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl();
 
+  void addMetaPackage() {
+    newFile('/.pub-cache/meta/lib/meta.dart', content: r'''
+library meta;
+
+const alwaysThrows = const Object();
+''');
+  }
+
   @override
   Future<TestAnalysisResult> resolveFile(String path) async {
     var result = await driver.getResult(path);
@@ -52,6 +60,7 @@
       'test': [getFolder('/test/lib')],
       'aaa': [getFolder('/aaa/lib')],
       'bbb': [getFolder('/bbb/lib')],
+      'meta': [getFolder('/.pub-cache/meta/lib')],
     };
 
     driver = new AnalysisDriver(
diff --git a/pkg/analyzer/test/src/dart/resolution/find_element.dart b/pkg/analyzer/test/src/dart/resolution/find_element.dart
index cbf7def..d0ac7bf 100644
--- a/pkg/analyzer/test/src/dart/resolution/find_element.dart
+++ b/pkg/analyzer/test/src/dart/resolution/find_element.dart
@@ -225,7 +225,7 @@
     unit.accept(new FunctionAstVisitor(
       variableDeclaration: (node) {
         var element = node.declaredElement;
-        if (element is LocalVariableElement) {
+        if (element is LocalVariableElement && element.name == name) {
           if (result != null) {
             fail('Not unique: $name');
           }
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 52e8428..7e7c6b3 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -284,15 +284,6 @@
         invocationImpl.methodNameType, expectedMethodNameType);
   }
 
-  void assertPropertyAccess(
-    PropertyAccess access,
-    Element expectedElement,
-    String expectedType,
-  ) {
-    assertElement(access.propertyName, expectedElement);
-    assertType(access, expectedType);
-  }
-
   void assertNamedParameterRef(String search, String name) {
     var ref = findNode.simple(search);
     assertElement(ref, findElement.parameter(name));
@@ -303,6 +294,15 @@
     assertTestErrors(const <ErrorCode>[]);
   }
 
+  void assertPropertyAccess(
+    PropertyAccess access,
+    Element expectedElement,
+    String expectedType,
+  ) {
+    assertElement(access.propertyName, expectedElement);
+    assertType(access, expectedType);
+  }
+
   void assertSuperExpression(SuperExpression superExpression) {
     // TODO(scheglov) I think `super` does not have type itself.
     // It is just a signal to look for implemented method in the supertype.