diff --git a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
index 8c4699a..e6e8921 100644
--- a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
@@ -362,7 +362,16 @@
   void doStatement_end(Expression condition);
 
   /// Call this method just after visiting a binary `==` or `!=` expression.
-  void equalityOp_end(Expression wholeExpression, Expression rightOperand,
+  ///
+  /// Return value indicates whether flow analysis believes that a successful
+  /// equality check is reachable.  If `false` is returned, the client should
+  /// ensure that the `==` test behaves like `x == y && throw ...`.
+  ///
+  /// Note that if `notEqual` is `true`, then the return value describes the
+  /// behavior of the underlying `==` test.  So if `notEqual` is `true` and
+  /// `false` is returned, the client should ensure that the `!=` test behaves
+  /// like `!(x == y && throw ...)`.
+  bool equalityOp_end(Expression wholeExpression, Expression rightOperand,
       Type rightOperandType,
       {bool notEqual = false});
 
@@ -475,7 +484,13 @@
 
   /// Call this method after visiting the LHS of an if-null expression ("??")
   /// or if-null assignment ("??=").
-  void ifNullExpression_rightBegin(Expression leftHandSide);
+  ///
+  /// Return value indicates whether flow analysis believes that the right hand
+  /// side is reachable.  If `false` is returned, the client should ensure that
+  /// `x ?? y` behaves like `x ?? throw ...` (or, correspondingly, that
+  /// `x ??= y` behaves like `x ??= throw ...`).
+  bool ifNullExpression_rightBegin(
+      Expression leftHandSide, Type leftHandSideType);
 
   /// Call this method after visiting the "then" part of an if statement, and
   /// before visiting the "else" part.
@@ -511,7 +526,16 @@
   /// be the expression to which the "is" check was applied.  [isNot] should be
   /// a boolean indicating whether this is an "is" or an "is!" expression.
   /// [type] should be the type being checked.
-  void isExpression_end(
+  ///
+  /// Return value indicates whether flow analysis believes that a failure of
+  /// the `is` test is reachable.  If `false` is returned, the client should
+  /// ensure that the `is` test behaves like `x is T || throw ...`.
+  ///
+  /// Note that if `isNot` is `true`, then the return value describes the
+  /// behavior of the underlying `if` test.  So if `isNot` is `true` and `false`
+  /// is returned, the client should ensure that the `is!` test behaves like
+  /// `!(x is T || throw ...)`.
+  bool isExpression_end(
       Expression isExpression, Expression subExpression, bool isNot, Type type);
 
   /// Return whether the [variable] is definitely unassigned in the current
@@ -558,12 +582,22 @@
   /// [target] should be the expression just before the null-aware operator, or
   /// `null` if the null-aware access starts a cascade section.
   ///
+  /// [targetType] should be the type of the expression just before the
+  /// null-aware operator, and should be non-null even if the null-aware access
+  /// starts a cascade section.
+  ///
   /// Note that [nullAwareAccess_end] should be called after the conclusion
   /// of any null-shorting that is caused by the `?.`.  So, for example, if the
   /// code being analyzed is `x?.y?.z(x)`, [nullAwareAccess_rightBegin] should
   /// be called once upon reaching each `?.`, but [nullAwareAccess_end] should
   /// not be called until after processing the method call to `z(x)`.
-  void nullAwareAccess_rightBegin(Expression target);
+  ///
+  /// Return value indicates whether flow analysis believes that a null target
+  /// is reachable.  If `false` is returned, the client should ensure that
+  /// `x?.y` behaves like `x!.y`.  (Note that this is necessary even if `y`
+  /// exists on `Object`--see
+  /// https://github.com/dart-lang/language/issues/1143#issuecomment-682096575.)
+  bool nullAwareAccess_rightBegin(Expression target, Type targetType);
 
   /// Call this method when encountering an expression that is a `null` literal.
   void nullLiteral(Expression expression);
@@ -811,15 +845,17 @@
   }
 
   @override
-  void equalityOp_end(Expression wholeExpression, Expression rightOperand,
+  bool equalityOp_end(Expression wholeExpression, Expression rightOperand,
       Type rightOperandType,
       {bool notEqual = false}) {
-    _wrap(
+    return _wrap(
         'equalityOp_end($wholeExpression, $rightOperand, $rightOperandType, '
         'notEqual: $notEqual)',
         () => _wrapped.equalityOp_end(
             wholeExpression, rightOperand, rightOperandType,
-            notEqual: notEqual));
+            notEqual: notEqual),
+        isQuery: true,
+        isPure: false);
   }
 
   @override
@@ -902,9 +938,14 @@
   }
 
   @override
-  void ifNullExpression_rightBegin(Expression leftHandSide) {
-    return _wrap('ifNullExpression_rightBegin($leftHandSide)',
-        () => _wrapped.ifNullExpression_rightBegin(leftHandSide));
+  bool ifNullExpression_rightBegin(
+      Expression leftHandSide, Type leftHandSideType) {
+    return _wrap(
+        'ifNullExpression_rightBegin($leftHandSide, $leftHandSideType)',
+        () => _wrapped.ifNullExpression_rightBegin(
+            leftHandSide, leftHandSideType),
+        isQuery: true,
+        isPure: false);
   }
 
   @override
@@ -931,12 +972,14 @@
   }
 
   @override
-  void isExpression_end(Expression isExpression, Expression subExpression,
+  bool isExpression_end(Expression isExpression, Expression subExpression,
       bool isNot, Type type) {
-    _wrap(
+    return _wrap(
         'isExpression_end($isExpression, $subExpression, $isNot, $type)',
-        () => _wrapped.isExpression_end(
-            isExpression, subExpression, isNot, type));
+        () =>
+            _wrapped.isExpression_end(isExpression, subExpression, isNot, type),
+        isQuery: true,
+        isPure: false);
   }
 
   @override
@@ -991,9 +1034,10 @@
   }
 
   @override
-  void nullAwareAccess_rightBegin(Expression target) {
-    _wrap('nullAwareAccess_rightBegin($target)',
-        () => _wrapped.nullAwareAccess_rightBegin(target));
+  bool nullAwareAccess_rightBegin(Expression target, Type targetType) {
+    return _wrap('nullAwareAccess_rightBegin($target, $targetType)',
+        () => _wrapped.nullAwareAccess_rightBegin(target, targetType),
+        isQuery: true, isPure: false);
   }
 
   @override
@@ -2456,7 +2500,7 @@
   }
 
   @override
-  void equalityOp_end(Expression wholeExpression, Expression rightOperand,
+  bool equalityOp_end(Expression wholeExpression, Expression rightOperand,
       Type rightOperandType,
       {bool notEqual = false}) {
     _EqualityOpContext<Variable, Type> context =
@@ -2471,14 +2515,16 @@
         typeOperations.classifyType(rightOperandType);
     if (leftOperandTypeClassification == TypeClassification.nullOrEquivalent &&
         rightOperandTypeClassification == TypeClassification.nullOrEquivalent) {
-      return booleanLiteral(wholeExpression, !notEqual);
+      booleanLiteral(wholeExpression, !notEqual);
+      return true;
     } else if ((leftOperandTypeClassification ==
                 TypeClassification.nullOrEquivalent &&
             rightOperandTypeClassification == TypeClassification.nonNullable) ||
         (rightOperandTypeClassification ==
                 TypeClassification.nullOrEquivalent &&
             leftOperandTypeClassification == TypeClassification.nonNullable)) {
-      return booleanLiteral(wholeExpression, notEqual);
+      booleanLiteral(wholeExpression, notEqual);
+      return false;
     } else if (lhsInfo is _NullInfo<Variable, Type> &&
         rhsInfo is _VariableReadInfo<Variable, Type>) {
       assert(
@@ -2490,10 +2536,11 @@
       equalityInfo =
           _current.tryMarkNonNullable(typeOperations, lhsInfo._variable);
     } else {
-      return;
+      return true;
     }
     _storeExpressionInfo(wholeExpression,
         notEqual ? equalityInfo : ExpressionInfo.invert(equalityInfo));
+    return equalityInfo.ifFalse.reachable;
   }
 
   @override
@@ -2619,7 +2666,8 @@
   }
 
   @override
-  void ifNullExpression_rightBegin(Expression leftHandSide) {
+  bool ifNullExpression_rightBegin(
+      Expression leftHandSide, Type leftHandSideType) {
     ExpressionInfo<Variable, Type> lhsInfo = _getExpressionInfo(leftHandSide);
     FlowModel<Variable, Type> promoted;
     if (lhsInfo is _VariableReadInfo<Variable, Type>) {
@@ -2630,7 +2678,12 @@
     } else {
       promoted = _current;
     }
+    if (typeOperations.classifyType(leftHandSideType) ==
+        TypeClassification.nonNullable) {
+      _current = _current.setReachable(false);
+    }
     _stack.add(new _SimpleContext<Variable, Type>(promoted));
+    return _current.reachable;
   }
 
   @override
@@ -2670,7 +2723,7 @@
   }
 
   @override
-  void isExpression_end(Expression isExpression, Expression subExpression,
+  bool isExpression_end(Expression isExpression, Expression subExpression,
       bool isNot, Type type) {
     ExpressionInfo<Variable, Type> subExpressionInfo =
         _getExpressionInfo(subExpression);
@@ -2678,12 +2731,13 @@
     if (subExpressionInfo is _VariableReadInfo<Variable, Type>) {
       variable = subExpressionInfo._variable;
     } else {
-      return;
+      return true;
     }
     ExpressionInfo<Variable, Type> expressionInfo =
         _current.tryPromoteForTypeCheck(typeOperations, variable, type);
     _storeExpressionInfo(isExpression,
         isNot ? ExpressionInfo.invert(expressionInfo) : expressionInfo);
+    return expressionInfo.ifFalse.reachable;
   }
 
   @override
@@ -2760,8 +2814,16 @@
   }
 
   @override
-  void nullAwareAccess_rightBegin(Expression target) {
-    _stack.add(new _SimpleContext<Variable, Type>(_current));
+  bool nullAwareAccess_rightBegin(Expression target, Type targetType) {
+    assert(targetType != null);
+    bool shortingIsReachable = true;
+    FlowModel<Variable, Type> shortingModel = _current;
+    if (typeOperations.classifyType(targetType) ==
+        TypeClassification.nonNullable) {
+      shortingModel = shortingModel.setReachable(false);
+      shortingIsReachable = false;
+    }
+    _stack.add(new _SimpleContext<Variable, Type>(shortingModel));
     if (target != null) {
       ExpressionInfo<Variable, Type> targetInfo = _getExpressionInfo(target);
       if (targetInfo is _VariableReadInfo<Variable, Type>) {
@@ -2770,6 +2832,7 @@
             .ifTrue;
       }
     }
+    return shortingIsReachable;
   }
 
   @override
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
index 09e6023..d512956 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
@@ -185,15 +185,76 @@
         var nullExpr = _Expression();
         flow.nullLiteral(nullExpr);
         var expr = _Expression();
-        flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: true);
+        var successIsReachable =
+            flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: true);
+        expect(successIsReachable, true);
         flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
         flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x), isNull);
         flow.ifStatement_end(true);
       });
     });
 
+    test('equalityOp(x != null) when x is non-nullable', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'int');
+      h.run((flow) {
+        h.declare(x, initialized: true);
+        var varExpr = _Expression();
+        flow.variableRead(varExpr, x);
+        flow.equalityOp_rightBegin(varExpr, _Type('int'));
+        var nullExpr = _Expression();
+        flow.nullLiteral(nullExpr);
+        var expr = _Expression();
+        var successIsReachable =
+            flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: true);
+        expect(successIsReachable, false);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
+        expect(flow.promotedType(x), isNull);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, false);
+        expect(flow.promotedType(x), isNull);
+        flow.ifStatement_end(true);
+      });
+    });
+
+    test('equalityOp(<expr> == <expr>) has no special effect', () {
+      var h = _Harness();
+      h.run((flow) {
+        flow.equalityOp_rightBegin(_Expression(), _Type('int?'));
+        var expr = _Expression();
+        var successIsReachable = flow.equalityOp_end(
+            expr, _Expression(), _Type('int?'),
+            notEqual: false);
+        expect(successIsReachable, true);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
+        flow.ifStatement_end(true);
+      });
+    });
+
+    test('equalityOp(<expr> != <expr>) has no special effect', () {
+      var h = _Harness();
+      h.run((flow) {
+        flow.equalityOp_rightBegin(_Expression(), _Type('int?'));
+        var expr = _Expression();
+        var successIsReachable = flow
+            .equalityOp_end(expr, _Expression(), _Type('int?'), notEqual: true);
+        expect(successIsReachable, true);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
+        flow.ifStatement_end(true);
+      });
+    });
+
     test('equalityOp(x != <null expr>) does not promote', () {
       var h = _Harness();
       var x = h.addVar('x', 'int?');
@@ -224,15 +285,43 @@
         var nullExpr = _Expression();
         flow.nullLiteral(nullExpr);
         var expr = _Expression();
-        flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: false);
+        var successIsReachable =
+            flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: false);
+        expect(successIsReachable, true);
         flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x), isNull);
         flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
         flow.ifStatement_end(true);
       });
     });
 
+    test('equalityOp(x == null) when x is non-nullable', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'int');
+      h.run((flow) {
+        h.declare(x, initialized: true);
+        var varExpr = _Expression();
+        flow.variableRead(varExpr, x);
+        flow.equalityOp_rightBegin(varExpr, _Type('int'));
+        var nullExpr = _Expression();
+        flow.nullLiteral(nullExpr);
+        var expr = _Expression();
+        var successIsReachable =
+            flow.equalityOp_end(expr, nullExpr, _Type('Null'), notEqual: false);
+        expect(successIsReachable, false);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, false);
+        expect(flow.promotedType(x), isNull);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
+        expect(flow.promotedType(x), isNull);
+        flow.ifStatement_end(true);
+      });
+    });
+
     test('equalityOp(null != x) promotes true branch', () {
       var h = _Harness();
       var x = h.addVar('x', 'int?');
@@ -299,7 +388,9 @@
         flow.equalityOp_rightBegin(null1, _Type('Null'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('Null'));
+        var successIsReachable =
+            flow.equalityOp_end(expr, null2, _Type('Null'));
+        expect(successIsReachable, true);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, true);
         flow.ifStatement_elseBegin();
@@ -315,7 +406,9 @@
         flow.equalityOp_rightBegin(null1, _Type('Null'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('Null'), notEqual: true);
+        var successIsReachable =
+            flow.equalityOp_end(expr, null2, _Type('Null'), notEqual: true);
+        expect(successIsReachable, true);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, false);
         flow.ifStatement_elseBegin();
@@ -331,7 +424,8 @@
         flow.equalityOp_rightBegin(null1, _Type('Null'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('int'));
+        var successIsReachable = flow.equalityOp_end(expr, null2, _Type('int'));
+        expect(successIsReachable, false);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, false);
         flow.ifStatement_elseBegin();
@@ -347,7 +441,9 @@
         flow.equalityOp_rightBegin(null1, _Type('Null'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('int'), notEqual: true);
+        var successIsReachable =
+            flow.equalityOp_end(expr, null2, _Type('int'), notEqual: true);
+        expect(successIsReachable, false);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, true);
         flow.ifStatement_elseBegin();
@@ -363,7 +459,9 @@
         flow.equalityOp_rightBegin(null1, _Type('int'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('Null'));
+        var successIsReachable =
+            flow.equalityOp_end(expr, null2, _Type('Null'));
+        expect(successIsReachable, false);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, false);
         flow.ifStatement_elseBegin();
@@ -379,7 +477,9 @@
         flow.equalityOp_rightBegin(null1, _Type('int'));
         var null2 = _Expression();
         var expr = _Expression();
-        flow.equalityOp_end(expr, null2, _Type('Null'), notEqual: true);
+        var successIsReachable =
+            flow.equalityOp_end(expr, null2, _Type('Null'), notEqual: true);
+        expect(successIsReachable, false);
         flow.ifStatement_thenBegin(expr);
         expect(flow.isReachable, true);
         flow.ifStatement_elseBegin();
@@ -885,10 +985,14 @@
       h.assignedVariables((vars) => vars.write(x));
       h.run((flow) {
         h.declare(x, initialized: true);
-        flow.ifNullExpression_rightBegin(h.variableRead(x)());
+        var rhsIsReachable = flow.ifNullExpression_rightBegin(
+            h.variableRead(x)(), _Type('int?'));
+        expect(rhsIsReachable, true);
+        expect(flow.isReachable, true);
         flow.write(x, _Type('int'));
         expect(flow.promotedType(x).type, 'int');
         flow.ifNullExpression_end();
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
       });
     });
@@ -898,10 +1002,14 @@
       var x = h.addVar('x', 'int?');
       h.run((flow) {
         h.declare(x, initialized: true);
-        flow.ifNullExpression_rightBegin(h.variableRead(x)());
+        var rhsIsReachable = flow.ifNullExpression_rightBegin(
+            h.variableRead(x)(), _Type('int?'));
+        expect(rhsIsReachable, true);
+        expect(flow.isReachable, true);
         h.promote(x, 'int');
         expect(flow.promotedType(x).type, 'int');
         flow.ifNullExpression_end();
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
       });
     });
@@ -911,14 +1019,43 @@
       var x = h.addVar('x', 'int?');
       h.run((flow) {
         h.declare(x, initialized: true);
-        flow.ifNullExpression_rightBegin(h.expr());
+        var rhsIsReachable =
+            flow.ifNullExpression_rightBegin(h.expr(), _Type('int?'));
+        expect(rhsIsReachable, true);
+        expect(flow.isReachable, true);
         h.promote(x, 'int');
         expect(flow.promotedType(x).type, 'int');
         flow.ifNullExpression_end();
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x), null);
       });
     });
 
+    test('ifNullExpression detects when RHS is unreachable', () {
+      var h = _Harness();
+      h.run((flow) {
+        var rhsIsReachable =
+            flow.ifNullExpression_rightBegin(h.expr(), _Type('int'));
+        expect(rhsIsReachable, false);
+        expect(flow.isReachable, false);
+        flow.ifNullExpression_end();
+        expect(flow.isReachable, true);
+      });
+    });
+
+    test('ifNullExpression determines reachability correctly for `Null` type',
+        () {
+      var h = _Harness();
+      h.run((flow) {
+        var rhsIsReachable =
+            flow.ifNullExpression_rightBegin(h.expr(), _Type('Null'));
+        expect(rhsIsReachable, true);
+        expect(flow.isReachable, true);
+        flow.ifNullExpression_end();
+        expect(flow.isReachable, true);
+      });
+    });
+
     test('ifStatement_end(false) keeps else branch if then branch exits', () {
       var h = _Harness();
       var x = h.addVar('x', 'int?');
@@ -932,11 +1069,12 @@
     });
 
     void _checkIs(
-      String declaredType,
-      String tryPromoteType,
-      String expectedPromotedTypeThen,
-      String expectedPromotedTypeElse,
-    ) {
+        String declaredType,
+        String tryPromoteType,
+        String expectedPromotedTypeThen,
+        String expectedPromotedTypeElse,
+        bool expectedFailureReachable,
+        {bool inverted = false}) {
       var h = _Harness();
       var x = h.addVar('x', declaredType);
       h.run((flow) {
@@ -944,14 +1082,18 @@
         var read = _Expression();
         flow.variableRead(read, x);
         var expr = _Expression();
-        flow.isExpression_end(expr, read, false, _Type(tryPromoteType));
+        var failureReachable =
+            flow.isExpression_end(expr, read, inverted, _Type(tryPromoteType));
+        expect(failureReachable, expectedFailureReachable);
         flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, inverted ? expectedFailureReachable : true);
         if (expectedPromotedTypeThen == null) {
           expect(flow.promotedType(x), isNull);
         } else {
           expect(flow.promotedType(x).type, expectedPromotedTypeThen);
         }
         flow.ifStatement_elseBegin();
+        expect(flow.isReachable, inverted ? true : expectedFailureReachable);
         if (expectedPromotedTypeElse == null) {
           expect(flow.promotedType(x), isNull);
         } else {
@@ -962,15 +1104,61 @@
     }
 
     test('isExpression_end promotes to a subtype', () {
-      _checkIs('int?', 'int', 'int', 'Never?');
+      _checkIs('int?', 'int', 'int', 'Never?', true);
+    });
+
+    test('isExpression_end promotes to a subtype, inverted', () {
+      _checkIs('int?', 'int', 'Never?', 'int', true, inverted: true);
     });
 
     test('isExpression_end does not promote to a supertype', () {
-      _checkIs('int', 'int?', null, 'Never');
+      _checkIs('int', 'int?', null, 'Never', false);
+    });
+
+    test('isExpression_end does not promote to a supertype, inverted', () {
+      _checkIs('int', 'int?', 'Never', null, false, inverted: true);
     });
 
     test('isExpression_end does not promote to an unrelated type', () {
-      _checkIs('int', 'String', null, null);
+      _checkIs('int', 'String', null, null, true);
+    });
+
+    test('isExpression_end does not promote to an unrelated type, inverted',
+        () {
+      _checkIs('int', 'String', null, null, true, inverted: true);
+    });
+
+    test('isExpression_end does nothing if applied to a non-variable', () {
+      var h = _Harness();
+      h.run((flow) {
+        var subExpr = _Expression();
+        var expr = _Expression();
+        var failureReachable =
+            flow.isExpression_end(expr, subExpr, false, _Type('int'));
+        expect(failureReachable, true);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
+        flow.ifStatement_end(true);
+      });
+    });
+
+    test('isExpression_end does nothing if applied to a non-variable, inverted',
+        () {
+      var h = _Harness();
+      h.run((flow) {
+        var subExpr = _Expression();
+        var expr = _Expression();
+        var failureReachable =
+            flow.isExpression_end(expr, subExpr, true, _Type('int'));
+        expect(failureReachable, true);
+        flow.ifStatement_thenBegin(expr);
+        expect(flow.isReachable, true);
+        flow.ifStatement_elseBegin();
+        expect(flow.isReachable, true);
+        flow.ifStatement_end(true);
+      });
     });
 
     test('isExpression_end() does not promote write-captured vars', () {
@@ -1153,7 +1341,10 @@
         h.declare(x, initialized: true);
         var varExpr = _Expression();
         flow.variableRead(varExpr, x);
-        flow.nullAwareAccess_rightBegin(varExpr);
+        var shortIsReachable =
+            flow.nullAwareAccess_rightBegin(varExpr, _Type('int?'));
+        expect(shortIsReachable, true);
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
         flow.nullAwareAccess_end();
         expect(flow.promotedType(x), isNull);
@@ -1167,7 +1358,10 @@
         h.declare(x, initialized: true);
         var varExpr = _Expression();
         flow.variableRead(varExpr, x);
-        flow.nullAwareAccess_rightBegin(null);
+        var shortIsReachable =
+            flow.nullAwareAccess_rightBegin(null, _Type('int?'));
+        expect(shortIsReachable, true);
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x), isNull);
         flow.nullAwareAccess_end();
       });
@@ -1181,7 +1375,10 @@
         h.declare(x, initialized: true);
         h.promote(x, 'int');
         var lhs = _Expression();
-        flow.nullAwareAccess_rightBegin(lhs);
+        var shortIsReachable =
+            flow.nullAwareAccess_rightBegin(lhs, _Type('int'));
+        expect(shortIsReachable, false);
+        expect(flow.isReachable, true);
         expect(flow.promotedType(x).type, 'int');
         flow.write(x, _Type('int?'));
         expect(flow.promotedType(x), isNull);
@@ -1190,6 +1387,24 @@
       });
     });
 
+    test('nullAwareAccess_end ignores shorting if target is non-nullable', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'int?');
+      h.run((flow) {
+        h.declare(x, initialized: true);
+        var shortIsReachable =
+            flow.nullAwareAccess_rightBegin(_Expression(), _Type('int'));
+        expect(shortIsReachable, false);
+        expect(flow.isReachable, true);
+        h.promote(x, 'int');
+        expect(flow.promotedType(x).type, 'int');
+        flow.nullAwareAccess_end();
+        // `x` should still be promoted because the target was non-nullable, so
+        // the null shorting path was unreachable.
+        expect(flow.promotedType(x).type, 'int');
+      });
+    });
+
     test('parenthesizedExpression preserves promotion behaviors', () {
       var h = _Harness();
       var x = h.addVar('x', 'int?');
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/if_null.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/if_null.dart
new file mode 100644
index 0000000..0cc336e
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/if_null.dart
@@ -0,0 +1,331 @@
+// Copyright (c) 2020, 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.
+
+void variable_if_null_reachable(int? i) {
+  i ?? 0;
+}
+
+void variable_if_null_assign_reachable(int? i) {
+  i ??= 0;
+}
+
+void variable_if_null_unreachable(int i) {
+  i ?? /*unreachable*/ 0;
+}
+
+void variable_if_null_assign_unreachable(int i) {
+  // Note: CFE reports that the update to `i` is unreachable; analyzer does not.
+  // This is ok; what matters is that the RHS is unreachable.
+  /*cfe.update: unreachable*/ i ??= /*unreachable*/ 0;
+}
+
+void variable_if_null_assign_unreachable_due_to_promotion(int? i) {
+  if (i == null) return;
+  // Note: CFE reports that the update to `i` is unreachable; analyzer does not.
+  // This is ok; what matters is that the RHS is unreachable.
+  /*cfe.update: unreachable*/ i ??= /*unreachable*/ 0;
+}
+
+/*member: topLevelNullable:doesNotComplete*/
+int? get topLevelNullable => 0;
+void set topLevelNullable(int? value) {}
+
+/*member: topLevelNonNullGet:doesNotComplete*/
+int get topLevelNonNullGet => 0;
+void set topLevelNonNullGet(int? value) {}
+
+void top_level_if_null_reachable() {
+  topLevelNullable ?? 0;
+}
+
+void top_level_if_null_assign_reachable() {
+  topLevelNullable ??= 0;
+}
+
+void top_level_if_null_unreachable() {
+  topLevelNonNullGet ?? /*unreachable*/ 0;
+}
+
+void top_level_if_null_assign_unreachable() {
+  // Note: CFE reports that the update to `topLevelNonNullGet` is unreachable;
+  // analyzer does not.  This is ok; what matters is that the RHS is
+  // unreachable.
+  topLevelNonNullGet /*cfe.update: unreachable*/ ??= /*unreachable*/ 0;
+}
+
+class HasProperty<T> {
+  /*member: HasProperty.prop:doesNotComplete*/
+  T get prop => throw '';
+  set prop(T? value) {}
+}
+
+void property_if_null_reachable(HasProperty<int?> x) {
+  x.prop ?? 0;
+}
+
+void property_if_null_assign_reachable(HasProperty<int?> x) {
+  x.prop ??= 0;
+}
+
+void property_if_null_unreachable(HasProperty<int> x) {
+  x.prop ?? /*unreachable*/ 0;
+}
+
+void property_if_null_assign_unreachable(HasProperty<int> x) {
+  x.prop ??= /*unreachable*/ 0;
+}
+
+void null_aware_property_if_null_reachable(HasProperty<int?>? x) {
+  x?.prop ?? 0;
+}
+
+void null_aware_property_if_null_assign_reachable(HasProperty<int?>? x) {
+  x?.prop ??= 0;
+}
+
+void null_aware_property_if_null_not_shortened(HasProperty<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  x?.prop ?? 0;
+}
+
+void null_aware_property_if_null_assign_unreachable(HasProperty<int>? x) {
+  x?.prop ??= /*unreachable*/ 0;
+}
+
+class SuperIntQuestionProperty extends HasProperty<int?> {
+  void if_null_reachable() {
+    super.prop ?? 0;
+  }
+
+  void if_null_assign_reachable() {
+    super.prop ??= 0;
+  }
+}
+
+class SuperIntProperty extends HasProperty<int> {
+  void if_null_unreachable() {
+    super.prop ?? /*unreachable*/ 0;
+  }
+
+  void if_null_assign_unreachable() {
+    super.prop ??= /*unreachable*/ 0;
+  }
+}
+
+extension ExtensionProperty<T> on HasProperty<T> {
+  /*member: ExtensionProperty|get#extendedProp:doesNotComplete*/
+  T get extendedProp => prop;
+  set extendedProp(T? value) {
+    prop = value;
+  }
+}
+
+void extended_property_if_null_reachable(HasProperty<int?> x) {
+  x.extendedProp ?? 0;
+}
+
+void extended_property_if_null_assign_reachable(HasProperty<int?> x) {
+  x.extendedProp ??= 0;
+}
+
+void extended_property_if_null_unreachable(HasProperty<int> x) {
+  x.extendedProp ?? /*unreachable*/ 0;
+}
+
+void extended_property_if_null_assign_unreachable(HasProperty<int> x) {
+  x.extendedProp ??= /*unreachable*/ 0;
+}
+
+void null_aware_extended_property_if_null_reachable(HasProperty<int?>? x) {
+  x?.extendedProp ?? 0;
+}
+
+void null_aware_extended_property_if_null_assign_reachable(
+    HasProperty<int?>? x) {
+  x?.extendedProp ??= 0;
+}
+
+void null_aware_extended_property_if_null_not_shortened(HasProperty<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  x?.extendedProp ?? 0;
+}
+
+void null_aware_extended_property_if_null_assign_unreachable(
+    HasProperty<int>? x) {
+  x?.extendedProp ??= /*unreachable*/ 0;
+}
+
+void explicit_extended_property_if_null_reachable(HasProperty<int?> x) {
+  ExtensionProperty(x).extendedProp ?? 0;
+}
+
+void explicit_extended_property_if_null_assign_reachable(HasProperty<int?> x) {
+  ExtensionProperty(x).extendedProp ??= 0;
+}
+
+void explicit_extended_property_if_null_unreachable(HasProperty<int> x) {
+  ExtensionProperty(x).extendedProp ?? /*unreachable*/ 0;
+}
+
+void explicit_extended_property_if_null_assign_unreachable(HasProperty<int> x) {
+  ExtensionProperty(x).extendedProp ??= /*unreachable*/ 0;
+}
+
+void null_aware_explicit_extended_property_if_null_reachable(
+    HasProperty<int?>? x) {
+  ExtensionProperty(x)?.extendedProp ?? 0;
+}
+
+void null_aware_explicit_extended_property_if_null_assign_reachable(
+    HasProperty<int?>? x) {
+  ExtensionProperty(x)?.extendedProp ??= 0;
+}
+
+void null_aware_explicit_extended_property_if_null_not_shortened(
+    HasProperty<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  ExtensionProperty(x)?.extendedProp ?? 0;
+}
+
+void null_aware_explicit_extended_property_if_null_assign_unreachable(
+    HasProperty<int>? x) {
+  ExtensionProperty(x)?.extendedProp ??= /*unreachable*/ 0;
+}
+
+class Indexable<T> {
+  /*member: Indexable.[]:doesNotComplete*/
+  T operator [](int index) => throw '';
+  operator []=(int index, T? value) {}
+}
+
+void index_if_null_reachable(Indexable<int?> x) {
+  x[0] ?? 0;
+}
+
+void index_if_null_unreachable(Indexable<int> x) {
+  x[0] ?? /*unreachable*/ 0;
+}
+
+void index_if_null_assign_reachable(Indexable<int?> x) {
+  x[0] ??= 0;
+}
+
+void index_if_null_assign_unreachable(Indexable<int> x) {
+  x[0] ??= /*unreachable*/ 0;
+}
+
+void null_aware_index_if_null_reachable(Indexable<int?>? x) {
+  x?[0] ?? 0;
+}
+
+void null_aware_index_if_null_unreachable(Indexable<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  x?[0] ?? 0;
+}
+
+void null_aware_index_if_null_assign_reachable(Indexable<int?>? x) {
+  x?[0] ??= 0;
+}
+
+void null_aware_index_if_null_assign_unreachable(Indexable<int>? x) {
+  x?[0] ??= /*unreachable*/ 0;
+}
+
+class SuperIntQuestionIndex extends Indexable<int?> {
+  void if_null_reachable() {
+    super[0] ?? 0;
+  }
+
+  void if_null_assign_reachable() {
+    super[0] ??= 0;
+  }
+}
+
+class SuperIntIndex extends Indexable<int> {
+  void if_null_unreachable() {
+    super[0] ?? /*unreachable*/ 0;
+  }
+
+  void if_null_assign_unreachable() {
+    super[0] ??= /*unreachable*/ 0;
+  }
+}
+
+extension ExtensionIndex<T> on HasProperty<T> {
+  /*member: ExtensionIndex|[]:doesNotComplete*/
+  T operator [](int index) => prop;
+  operator []=(int index, T? value) {
+    prop = value;
+  }
+}
+
+void extended_index_if_null_reachable(HasProperty<int?> x) {
+  x[0] ?? 0;
+}
+
+void extended_index_if_null_assign_reachable(HasProperty<int?> x) {
+  x[0] ??= 0;
+}
+
+void extended_index_if_null_unreachable(HasProperty<int> x) {
+  x[0] ?? /*unreachable*/ 0;
+}
+
+void extended_index_if_null_assign_unreachable(HasProperty<int> x) {
+  x[0] ??= /*unreachable*/ 0;
+}
+
+void null_aware_extended_index_if_null_reachable(HasProperty<int?>? x) {
+  x?[0] ?? 0;
+}
+
+void null_aware_extended_index_if_null_assign_reachable(HasProperty<int?>? x) {
+  x?[0] ??= 0;
+}
+
+void null_aware_extended_index_if_null_not_shortened(HasProperty<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  x?[0] ?? 0;
+}
+
+void null_aware_extended_index_if_null_assign_unreachable(HasProperty<int>? x) {
+  x?[0] ??= /*unreachable*/ 0;
+}
+
+void explicit_extended_index_if_null_reachable(HasProperty<int?> x) {
+  ExtensionIndex(x)[0] ?? 0;
+}
+
+void explicit_extended_index_if_null_assign_reachable(HasProperty<int?> x) {
+  ExtensionIndex(x)[0] ??= 0;
+}
+
+void explicit_extended_index_if_null_unreachable(HasProperty<int> x) {
+  ExtensionIndex(x)[0] ?? /*unreachable*/ 0;
+}
+
+void explicit_extended_index_if_null_assign_unreachable(HasProperty<int> x) {
+  ExtensionIndex(x)[0] ??= /*unreachable*/ 0;
+}
+
+void null_aware_explicit_extended_index_if_null_reachable(
+    HasProperty<int?>? x) {
+  ExtensionIndex(x)?[0] ?? 0;
+}
+
+void null_aware_explicit_extended_index_if_null_assign_reachable(
+    HasProperty<int?>? x) {
+  ExtensionIndex(x)?[0] ??= 0;
+}
+
+void null_aware_explicit_extended_index_if_null_not_shortened(
+    HasProperty<int>? x) {
+  // If `??` participated in null-shortening, `0` would be unreachable.
+  ExtensionIndex(x)?[0] ?? 0;
+}
+
+void null_aware_explicit_extended_index_if_null_assign_unreachable(
+    HasProperty<int>? x) {
+  ExtensionIndex(x)?[0] ??= /*unreachable*/ 0;
+}
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access.dart
new file mode 100644
index 0000000..a204bf8
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access.dart
@@ -0,0 +1,131 @@
+// Copyright (c) 2020, 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.
+
+void index_reachable(List<int>? f()) {
+  f()?[throw ''];
+  0;
+}
+
+/*member: index_unreachable:doesNotComplete*/
+void index_unreachable(List<int> f()) {
+  f()?[throw ''];
+  /*stmt: unreachable*/ 0;
+}
+
+void cascaded_index_reachable(List<int>? f()) {
+  f()?..[throw ''];
+  0;
+}
+
+/*member: cascaded_index_unreachable:doesNotComplete*/
+void cascaded_index_unreachable(List<int> f()) {
+  f()?..[throw ''];
+  /*stmt: unreachable*/ 0;
+}
+
+void method_invocation_reachable(int? f()) {
+  f()?.remainder(throw '');
+  0;
+}
+
+/*member: method_invocation_unreachable:doesNotComplete*/
+void method_invocation_unreachable(int f()) {
+  f()?.remainder(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+void cascaded_method_invocation_reachable(int? f()) {
+  f()?..remainder(throw '');
+  0;
+}
+
+/*member: cascaded_method_invocation_unreachable:doesNotComplete*/
+void cascaded_method_invocation_unreachable(int f()) {
+  f()?..remainder(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+void property_get_reachable(int? f()) {
+  f()?.hashCode.remainder(throw '');
+  0;
+}
+
+/*member: property_get_unreachable:doesNotComplete*/
+void property_get_unreachable(int f()) {
+  f()?.hashCode.remainder(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+void cascaded_property_get_reachable(int? f()) {
+  f()?..hashCode.remainder(throw '');
+  0;
+}
+
+/*member: cascaded_property_get_unreachable:doesNotComplete*/
+void cascaded_property_get_unreachable(int f()) {
+  f()?..hashCode.remainder(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+void property_get_invocation_reachable(List<void Function(dynamic)>? f()) {
+  // We need a special test case for this because it parses like a method
+  // invocation but the analyzer rewrites it as a property access followed by a
+  // function expression invocation.
+  f()?.first(throw '');
+  0;
+}
+
+/*member: property_get_invocation_unreachable:doesNotComplete*/
+void property_get_invocation_unreachable(List<void Function(dynamic)> f()) {
+  // We need a special test case for this because it parses like a method
+  // invocation but the analyzer rewrites it as a property access followed by a
+  // function expression invocation.
+  f()?.first(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+void cascaded_property_get_invocation_reachable(
+    List<void Function(dynamic)>? f()) {
+  // We need a special test case for this because it parses like a method
+  // invocation but the analyzer rewrites it as a property access followed by a
+  // function expression invocation.
+  f()?..first(throw '');
+  0;
+}
+
+/*member: cascaded_property_get_invocation_unreachable:doesNotComplete*/
+void cascaded_property_get_invocation_unreachable(
+    List<void Function(dynamic)> f()) {
+  // We need a special test case for this because it parses like a method
+  // invocation but the analyzer rewrites it as a property access followed by a
+  // function expression invocation.
+  f()?..first(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+class C {
+  int field = 0;
+}
+
+void property_set_reachable(C? f()) {
+  f()?.field = throw '';
+  0;
+}
+
+/*member: property_set_unreachable:doesNotComplete*/
+void property_set_unreachable(C f()) {
+  f()?.field = throw '';
+  /*stmt: unreachable*/ 0;
+}
+
+void cascaded_property_set_reachable(C? f()) {
+  f()?..field = throw '';
+  0;
+}
+
+/*member: cascaded_property_set_unreachable:doesNotComplete*/
+void cascaded_property_set_unreachable(C f()) {
+  f()?..field = throw '';
+  /*stmt: unreachable*/ 0;
+}
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access_static.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access_static.dart
new file mode 100644
index 0000000..4edebe4
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/reachability/data/null_aware_access_static.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2020, 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.
+
+class C {
+  static void staticMethod(dynamic d) {}
+  /*member: C.staticGetter:doesNotComplete*/
+  static int get staticGetter => 0;
+  /*member: C.staticInvokableGetter:doesNotComplete*/
+  static void Function(dynamic d) get staticInvokableGetter => (_) {};
+  static void set staticSetter(int value) {}
+}
+
+/*member: method_invocation_unreachable:doesNotComplete*/
+void method_invocation_unreachable() {
+  C?.staticMethod(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+/*member: property_get_unreachable:doesNotComplete*/
+void property_get_unreachable() {
+  C?.staticGetter.remainder(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+/*member: property_get_invocation_unreachable:doesNotComplete*/
+void property_get_invocation_unreachable() {
+  // We need a special test case for this because it parses like a method
+  // invocation but the analyzer rewrites it as a property access followed by a
+  // function expression invocation.
+  C?.staticInvokableGetter(throw '');
+  /*stmt: unreachable*/ 0;
+}
+
+/*member: property_set_unreachable:doesNotComplete*/
+void property_set_unreachable() {
+  C?.staticSetter = throw '';
+  /*stmt: unreachable*/ 0;
+}
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
index d6330c2..f5e89d2 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
@@ -16,22 +16,63 @@
 class TransformSetParser {
   static const String _changesKey = 'changes';
 
-  static const String _componentsKey = 'components';
+  static const String _classKey = 'class';
+
+  static const String _constructorKey = 'constructor';
 
   static const String _elementKey = 'element';
 
+  static const String _enumConstantKey = 'constant';
+
+  static const String _enumKey = 'enum';
+
+  static const String _extensionKey = 'extension';
+
+  static const String _fieldKey = 'field';
+
+  static const String _functionKey = 'function';
+
+  static const String _getterKey = 'getter';
+
+  static const String _inClassKey = 'inClass';
+
+  static const String _inEnumKey = 'inEnum';
+
+  static const String _inExtensionKey = 'inExtension';
+
+  static const String _inMixinKey = 'inMixin';
+
   static const String _kindKey = 'kind';
 
+  static const String _methodKey = 'method';
+
+  static const String _mixinKey = 'mixin';
+
   static const String _newNameKey = 'newName';
 
+  static const String _setterKey = 'setter';
+
   static const String _titleKey = 'title';
 
   static const String _transformsKey = 'transforms';
 
+  static const String _typedefKey = 'typedef';
+
   static const String _urisKey = 'uris';
 
   static const String _versionKey = 'version';
 
+  /// A table mapping top-level keys for member elements to the list of keys for
+  /// the possible containers of that element.
+  static const Map<String, List<String>> _containerKeyMap = {
+    _constructorKey: [_inClassKey],
+    _enumConstantKey: [_inEnumKey],
+    _fieldKey: [_inClassKey, _inExtensionKey, _inMixinKey],
+    _getterKey: [_inClassKey, _inExtensionKey, _inMixinKey],
+    _methodKey: [_inClassKey, _inExtensionKey, _inMixinKey],
+    _setterKey: [_inClassKey, _inExtensionKey, _inMixinKey],
+  };
+
   static const String _renameKind = 'rename';
 
   static const int currentVersion = 1;
@@ -91,6 +132,34 @@
     }
   }
 
+  /// Given a [map] and a set of [validKeys], ensure that only one of those keys
+  /// is in the map and return it. If more than one of the keys is in the map,
+  /// report a diagnostic.
+  String _singleKey(YamlMap map, List<String> validKeys) {
+    if (validKeys == null) {
+      return null;
+    }
+    var foundKeys = <String>[];
+    var keyToNodeMap = <String, YamlNode>{};
+    for (var keyNode in map.nodes.keys) {
+      if (keyNode is YamlScalar) {
+        var key = _translateString(keyNode);
+        if (key != null && validKeys.contains(key)) {
+          foundKeys.add(key);
+          keyToNodeMap[key] = keyNode;
+        }
+      }
+    }
+    if (foundKeys.isEmpty) {
+      return null;
+    }
+    for (var i = 1; i < foundKeys.length; i++) {
+      // var invalidNode = keyToNodeMap[foundKeys[i]];
+      // TODO(brianwilkerson) Report the invalid key.
+    }
+    return foundKeys[0];
+  }
+
   /// Translate the [node] into a change. Return the resulting change, or `null`
   /// if the [node] does not represent a valid change.
   Change _translateChange(YamlNode node) {
@@ -118,15 +187,42 @@
     if (node is YamlMap) {
       var uris = _translateList(node.valueAt(_urisKey), _translateString);
       if (uris == null) {
+        // TODO(brianwilkerson) Returning here prevents other errors from being
+        //  reported.
         // The error has already been reported.
         return null;
       }
-      var components =
-          _translateList(node.valueAt(_componentsKey), _translateString);
-      if (components == null) {
+      var elementKey = _singleKey(node, [
+        _classKey,
+        _enumConstantKey,
+        _constructorKey,
+        _enumKey,
+        _extensionKey,
+        _fieldKey,
+        _functionKey,
+        _getterKey,
+        _methodKey,
+        _mixinKey,
+        _setterKey,
+        _typedefKey
+      ]);
+      var elementName = _translateString(node.valueAt(elementKey));
+      if (elementName == null) {
         // The error has already been reported.
         return null;
       }
+      var components = [elementName];
+      var containerKey = _singleKey(node, _containerKeyMap[elementKey]);
+      var containerName = _translateString(node.valueAt(containerKey));
+      if (containerName == null) {
+        if ([_constructorKey, _enumConstantKey, _methodKey, _fieldKey]
+            .contains(elementKey)) {
+          // TODO(brianwilkerson) Report that no container was found.
+          return null;
+        }
+      } else {
+        components.insert(0, containerName);
+      }
       return ElementDescriptor(libraryUris: uris, components: components);
     } else if (node == null) {
       // TODO(brianwilkerson) Report the missing YAML.
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/end_to_end_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/end_to_end_test.dart
index e483534..58dd53a 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/end_to_end_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/end_to_end_test.dart
@@ -25,8 +25,7 @@
   element:
     uris:
       - '$importUri'
-    components:
-      - 'Old'
+    class: 'Old'
   changes:
     - kind: 'rename'
       newName: 'New'
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
index 336979b..f36fef5 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
@@ -18,6 +18,59 @@
 
 @reflectiveTest
 class TransformSetParserTest extends AbstractTransformSetParserTest {
+  void test_element_getter_inMixin() {
+    parse('''
+version: 1
+transforms:
+- title: 'Rename g'
+  element:
+    uris: ['test.dart']
+    getter: 'g'
+    inMixin: 'A'
+  changes: []
+''');
+    var transforms = result.transformsFor('g', ['test.dart']);
+    expect(transforms, hasLength(1));
+    var transform = transforms[0];
+    expect(transform.title, 'Rename g');
+    expect(transform.changes, isEmpty);
+  }
+
+  void test_element_getter_topLevel() {
+    parse('''
+version: 1
+transforms:
+- title: 'Rename g'
+  element:
+    uris: ['test.dart']
+    getter: 'g'
+  changes: []
+''');
+    var transforms = result.transformsFor('g', ['test.dart']);
+    expect(transforms, hasLength(1));
+    var transform = transforms[0];
+    expect(transform.title, 'Rename g');
+    expect(transform.changes, isEmpty);
+  }
+
+  void test_element_method_inClass() {
+    parse('''
+version: 1
+transforms:
+- title: 'Rename m'
+  element:
+    uris: ['test.dart']
+    method: 'm'
+    inClass: 'A'
+  changes: []
+''');
+    var transforms = result.transformsFor('m', ['test.dart']);
+    expect(transforms, hasLength(1));
+    var transform = transforms[0];
+    expect(transform.title, 'Rename m');
+    expect(transform.changes, isEmpty);
+  }
+
   void test_incomplete() {
     parse('''
 version: 1
@@ -46,8 +99,7 @@
   element:
     uris:
       - 'test.dart'
-    components:
-      - 'A'
+    class: 'A'
   changes:
     - kind: 'rename'
       newName: 'B'
diff --git a/pkg/analysis_server/test/src/services/correction/fix/remove_if_null_operator_test.dart b/pkg/analysis_server/test/src/services/correction/fix/remove_if_null_operator_test.dart
index 32b927a..28948d0 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/remove_if_null_operator_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/remove_if_null_operator_test.dart
@@ -5,6 +5,7 @@
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/linter/lint_names.dart';
 import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -31,7 +32,10 @@
 ''');
     await assertHasFix('''
 int f(int a, int b) => a;
-''');
+''', errorFilter: (e) {
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      return e.errorCode != HintCode.DEAD_CODE;
+    });
   }
 
   Future<void> test_nestedChild() async {
@@ -40,7 +44,10 @@
 ''');
     await assertHasFix('''
 int f(int a, int b) => a;
-''');
+''', errorFilter: (e) {
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      return e.errorCode != HintCode.DEAD_CODE;
+    });
   }
 }
 
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 3cf8743..0cacd29 100644
--- a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
@@ -466,7 +466,7 @@
 
     var flow = _flowAnalysis?.flow;
     if (flow != null && operator == TokenType.QUESTION_QUESTION_EQ) {
-      flow.ifNullExpression_rightBegin(left);
+      flow.ifNullExpression_rightBegin(left, node.readType);
     }
 
     right?.accept(_resolver);
diff --git a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
index fe41371..ddab194 100644
--- a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
@@ -178,7 +178,7 @@
     }
     InferenceContext.setType(right, rightContextType);
 
-    flow?.ifNullExpression_rightBegin(left);
+    flow?.ifNullExpression_rightBegin(left, leftType);
     right.accept(_resolver);
     right = node.rightOperand;
     flow?.ifNullExpression_end();
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 1c2938f1..915f509 100644
--- a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
@@ -85,7 +85,7 @@
     if (flow == null) return null;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
-      flow.ifNullExpression_rightBegin(node.leftHandSide);
+      flow.ifNullExpression_rightBegin(node.leftHandSide, node.readType);
     }
   }
 
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 0c60e48..d1fedd3 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -850,7 +850,8 @@
     node.target.accept(this);
 
     if (node.isNullAware && _isNonNullableByDefault) {
-      _flowAnalysis.flow.nullAwareAccess_rightBegin(node.target);
+      _flowAnalysis.flow.nullAwareAccess_rightBegin(
+          node.target, node.target.staticType ?? typeProvider.dynamicType);
       _unfinishedNullShorts.add(node.nullShortingTermination);
     }
 
@@ -1447,7 +1448,8 @@
     node.target?.accept(this);
     if (_migratableAstInfoProvider.isIndexExpressionNullAware(node) &&
         _isNonNullableByDefault) {
-      _flowAnalysis.flow.nullAwareAccess_rightBegin(node.target);
+      _flowAnalysis.flow.nullAwareAccess_rightBegin(
+          node.target, node.realTarget.staticType ?? typeProvider.dynamicType);
       _unfinishedNullShorts.add(node.nullShortingTermination);
     }
     node.accept(elementResolver);
@@ -1534,12 +1536,18 @@
 
   @override
   void visitMethodInvocation(MethodInvocation node) {
-    node.target?.accept(this);
+    var target = node.target;
+    target?.accept(this);
 
     if (_migratableAstInfoProvider.isMethodInvocationNullAware(node) &&
         _isNonNullableByDefault) {
-      _flowAnalysis.flow.nullAwareAccess_rightBegin(node.target);
-      _unfinishedNullShorts.add(node.nullShortingTermination);
+      if (target is SimpleIdentifier && target.staticElement is ClassElement) {
+        // `?.` to access static methods is equivalent to `.`, so do nothing.
+      } else {
+        _flowAnalysis.flow.nullAwareAccess_rightBegin(
+            target, node.realTarget.staticType ?? typeProvider.dynamicType);
+        _unfinishedNullShorts.add(node.nullShortingTermination);
+      }
     }
 
     node.typeArguments?.accept(this);
@@ -1632,11 +1640,17 @@
     // We visit the target, but do not visit the property name because it needs
     // to be visited in the context of the property access node.
     //
-    node.target?.accept(this);
+    var target = node.target;
+    target?.accept(this);
     if (_migratableAstInfoProvider.isPropertyAccessNullAware(node) &&
         _isNonNullableByDefault) {
-      _flowAnalysis.flow.nullAwareAccess_rightBegin(node.target);
-      _unfinishedNullShorts.add(node.nullShortingTermination);
+      if (target is SimpleIdentifier && target.staticElement is ClassElement) {
+        // `?.` to access static methods is equivalent to `.`, so do nothing.
+      } else {
+        _flowAnalysis.flow.nullAwareAccess_rightBegin(
+            target, node.realTarget.staticType ?? typeProvider.dynamicType);
+        _unfinishedNullShorts.add(node.nullShortingTermination);
+      }
     }
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
@@ -2006,8 +2020,14 @@
     if (function is PropertyAccess &&
         _migratableAstInfoProvider.isPropertyAccessNullAware(function) &&
         _isNonNullableByDefault) {
-      _flowAnalysis.flow.nullAwareAccess_rightBegin(function);
-      _unfinishedNullShorts.add(node.nullShortingTermination);
+      var target = function.target;
+      if (target is SimpleIdentifier && target.staticElement is ClassElement) {
+        // `?.` to access static methods is equivalent to `.`, so do nothing.
+      } else {
+        _flowAnalysis.flow.nullAwareAccess_rightBegin(function,
+            function.realTarget.staticType ?? typeProvider.dynamicType);
+        _unfinishedNullShorts.add(node.nullShortingTermination);
+      }
     }
 
     _functionExpressionInvocationResolver.resolve(node);
diff --git a/pkg/analyzer/lib/src/util/ast_data_extractor.dart b/pkg/analyzer/lib/src/util/ast_data_extractor.dart
index 06fdab9..2147db8 100644
--- a/pkg/analyzer/lib/src/util/ast_data_extractor.dart
+++ b/pkg/analyzer/lib/src/util/ast_data_extractor.dart
@@ -84,6 +84,13 @@
       var memberName = element.name;
       var className = element.enclosingElement.name;
       return MemberId.internal(memberName, className: className);
+    } else if (element.enclosingElement is ExtensionElement) {
+      var memberName = element.name;
+      var extensionName = element.enclosingElement.name;
+      if (element is PropertyAccessorElement) {
+        memberName = '${element.isGetter ? 'get' : 'set'}#$memberName';
+      }
+      return MemberId.internal('$extensionName|$memberName');
     }
     throw UnimplementedError(
         'TODO(paulberry): $element (${element.runtimeType})');
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index c616675..95d7b3e 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -445,19 +445,17 @@
 
   test_async_expression_function_type() async {
     await assertErrorsInCode('''
-import 'dart:async';
 typedef Future<int> F(int i);
 main() {
   F f = (int i) async => i;
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 64, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1),
     ]);
   }
 
   test_async_flattened() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 typedef Future<int> CreatesFutureInt();
 main() {
   CreatesFutureInt createFutureInt = () async => f();
@@ -470,7 +468,6 @@
 
   test_async_future_dynamic_with_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<dynamic> f() async {
   return;
 }
@@ -479,7 +476,6 @@
 
   test_async_future_dynamic_with_return_value() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<dynamic> f() async {
   return 5;
 }
@@ -488,14 +484,12 @@
 
   test_async_future_dynamic_without_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<dynamic> f() async {}
 ''');
   }
 
   test_async_future_int_with_return_future_int() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<int> f() async {
   return new Future<int>.value(5);
 }
@@ -504,7 +498,6 @@
 
   test_async_future_int_with_return_value() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<int> f() async {
   return 5;
 }
@@ -513,7 +506,6 @@
 
   test_async_future_null_with_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<Null> f() async {
   return;
 }
@@ -522,14 +514,12 @@
 
   test_async_future_null_without_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<Null> f() async {}
 ''');
   }
 
   test_async_future_object_with_return_value() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<Object> f() async {
   return 5;
 }
@@ -538,7 +528,6 @@
 
   test_async_future_with_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future f() async {
   return;
 }
@@ -547,7 +536,6 @@
 
   test_async_future_with_return_value() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future f() async {
   return 5;
 }
@@ -556,7 +544,6 @@
 
   test_async_future_without_return() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future f() async {}
 ''');
   }
@@ -607,25 +594,23 @@
 
   test_await_flattened() async {
     await assertErrorsInCode('''
-import 'dart:async';
 Future<Future<int>> ffi() => null;
 f() async {
   Future<int> b = await ffi();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 82, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 1),
     ]);
   }
 
   test_await_simple() async {
     await assertErrorsInCode('''
-import 'dart:async';
 Future<int> fi() => null;
 f() async {
   int a = await fi();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 65, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 44, 1),
     ]);
   }
 
@@ -1099,7 +1084,6 @@
 
   test_empty_generator_async() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Stream<int> f() async* {
 }
 ''');
@@ -2147,8 +2131,6 @@
 
   test_issue_24191() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 abstract class S extends Stream {}
 f(S s) async {
   await for (var v in s) {
diff --git a/pkg/analyzer/test/generated/static_type_warning_code_test.dart b/pkg/analyzer/test/generated/static_type_warning_code_test.dart
index 0256b50..e29bb22 100644
--- a/pkg/analyzer/test/generated/static_type_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_type_warning_code_test.dart
@@ -40,126 +40,116 @@
 
   test_await_flattened() async {
     await assertErrorsInCode('''
-import 'dart:async';
 Future<Future<int>> ffi() => null;
 f() async {
   Future<int> b = await ffi(); 
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 82, 1),
-    ]);
-  }
-
-  test_await_simple() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-Future<int> fi() => null;
-f() async {
-  String a = await fi(); // Warning: int not assignable to String
-}
-''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 68, 1),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 72, 10),
-    ]);
-  }
-
-  test_awaitForIn_declaredVariableRightType() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-f() async {
-  Stream<int> stream;
-  await for (int i in stream) {}
-}
-''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 72, 1),
-    ]);
-  }
-
-  test_awaitForIn_declaredVariableWrongType() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-f() async {
-  Stream<String> stream;
-  await for (int i in stream) {}
-}
-''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 75, 1),
-      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 80, 6),
-    ]);
-  }
-
-  test_awaitForIn_downcast() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-f() async {
-  Stream<num> stream;
-  await for (int i in stream) {}
-}
-''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 72, 1),
-    ]);
-  }
-
-  test_awaitForIn_dynamicVariable() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-f() async {
-  Stream<int> stream;
-  await for (var i in stream) {}
-}
-''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 72, 1),
-    ]);
-  }
-
-  test_awaitForIn_existingVariableRightType() async {
-    await assertErrorsInCode('''
-import 'dart:async';
-f() async {
-  Stream<int> stream;
-  int i;
-  await for (i in stream) {}
-}
-''', [
       error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 1),
     ]);
   }
 
+  test_await_simple() async {
+    await assertErrorsInCode('''
+Future<int> fi() => null;
+f() async {
+  String a = await fi(); // Warning: int not assignable to String
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 47, 1),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 51, 10),
+    ]);
+  }
+
+  test_awaitForIn_declaredVariableRightType() async {
+    await assertErrorsInCode('''
+f() async {
+  Stream<int> stream;
+  await for (int i in stream) {}
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 51, 1),
+    ]);
+  }
+
+  test_awaitForIn_declaredVariableWrongType() async {
+    await assertErrorsInCode('''
+f() async {
+  Stream<String> stream;
+  await for (int i in stream) {}
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 54, 1),
+      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 59, 6),
+    ]);
+  }
+
+  test_awaitForIn_downcast() async {
+    await assertErrorsInCode('''
+f() async {
+  Stream<num> stream;
+  await for (int i in stream) {}
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 51, 1),
+    ]);
+  }
+
+  test_awaitForIn_dynamicVariable() async {
+    await assertErrorsInCode('''
+f() async {
+  Stream<int> stream;
+  await for (var i in stream) {}
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 51, 1),
+    ]);
+  }
+
+  test_awaitForIn_existingVariableRightType() async {
+    await assertErrorsInCode('''
+f() async {
+  Stream<int> stream;
+  int i;
+  await for (i in stream) {}
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 40, 1),
+    ]);
+  }
+
   test_awaitForIn_existingVariableWrongType() async {
     await assertErrorsInCode('''
-import 'dart:async';
 f() async {
   Stream<String> stream;
   int i;
   await for (i in stream) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 64, 1),
-      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 85, 6),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1),
+      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 64, 6),
     ]);
   }
 
   test_awaitForIn_streamOfDynamic() async {
     await assertErrorsInCode('''
-import 'dart:async';
 f() async {
   Stream stream;
   await for (int i in stream) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 67, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 46, 1),
     ]);
   }
 
   test_awaitForIn_upcast() async {
     await assertErrorsInCode('''
-import 'dart:async';
 f() async {
   Stream<int> stream;
   await for (num i in stream) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 72, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 51, 1),
     ]);
   }
 
@@ -600,7 +590,6 @@
 class StrongModeStaticTypeWarningCodeTest extends PubPackageResolutionTest {
   test_legalAsyncGeneratorReturnType_function_supertypeOfStream() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 f() async* { yield 42; }
 dynamic f2() async* { yield 42; }
 Object f3() async* { yield 42; }
@@ -614,7 +603,6 @@
 
   test_legalAsyncReturnType_function_supertypeOfFuture() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 f() async { return 42; }
 dynamic f2() async { return 42; }
 Object f3() async { return 42; }
diff --git a/pkg/analyzer/test/generated/strong_mode_test.dart b/pkg/analyzer/test/generated/strong_mode_test.dart
index e46eb3b..f219504 100644
--- a/pkg/analyzer/test/generated/strong_mode_test.dart
+++ b/pkg/analyzer/test/generated/strong_mode_test.dart
@@ -87,7 +87,6 @@
 
   test_async_method_propagation() async {
     String code = r'''
-      import "dart:async";
       class A {
         Future f0() => new Future.value(3);
         Future f1() async => new Future.value(3);
@@ -144,8 +143,6 @@
 
   test_async_propagation() async {
     String code = r'''
-      import "dart:async";
-
       Future f0() => new Future.value(3);
       Future f1() async => new Future.value(3);
       Future f2() async => await new Future.value(3);
@@ -3378,14 +3375,13 @@
 
   test_genericMethod_then() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 String toString(int x) => x.toString();
 main() {
   Future<int> bar = null;
   var foo = bar.then(toString);
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 102, 3),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 81, 3),
     ]);
 
     expectInitializerType('foo', 'Future<String>');
@@ -3408,14 +3404,13 @@
   test_genericMethod_then_propagatedType() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/25482.
     await assertErrorsInCode(r'''
-import 'dart:async';
 void main() {
   Future<String> p;
   var foo = p.then((r) => new Future<String>.value(3));
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 3),
-      error(CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 106, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 40, 3),
+      error(CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 85, 1),
     ]);
     // Note: this correctly reports the error
     // CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE when run with the driver;
@@ -3978,7 +3973,6 @@
 
   test_foreachInference_var_stream() async {
     await resolveTestCode(r'''
-import 'dart:async';
 main() async {
   Stream<int> stream = null;
   await for (var v in stream) {
diff --git a/pkg/analyzer/test/src/dart/resolution/await_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/await_expression_test.dart
index fe0faac..e2baade 100644
--- a/pkg/analyzer/test/src/dart/resolution/await_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/await_expression_test.dart
@@ -17,8 +17,6 @@
 class AwaitExpressionResolutionTest extends PubPackageResolutionTest {
   test_future() async {
     await assertNoErrorsInCode(r'''
-import 'dart:async';
-
 f(Future<int> a) async {
   await a;
 }
@@ -57,8 +55,6 @@
 
   test_futureQ() async {
     await assertNoErrorsInCode(r'''
-import 'dart:async';
-
 f(Future<int>? a) async {
   await a;
 }
diff --git a/pkg/analyzer/test/src/diagnostics/dead_null_aware_expression_test.dart b/pkg/analyzer/test/src/diagnostics/dead_null_aware_expression_test.dart
index c1e4746..e60e478 100644
--- a/pkg/analyzer/test/src/diagnostics/dead_null_aware_expression_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/dead_null_aware_expression_test.dart
@@ -22,13 +22,16 @@
 var x = 0;
 ''');
 
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 import 'a.dart';
 
 f() {
   x ??= 0;
 }
-''');
+''', [
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 32, 2),
+    ]);
   }
 
   test_assignCompound_map() async {
@@ -51,6 +54,8 @@
 }
 ''', [
       error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 19, 1),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 19, 2),
     ]);
   }
 
@@ -68,13 +73,16 @@
 var x = 0;
 ''');
 
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 import 'a.dart';
 
 f() {
   x ?? 0;
 }
-''');
+''', [
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 31, 2),
+    ]);
   }
 
   test_binary_nonNullable() async {
@@ -84,6 +92,8 @@
 }
 ''', [
       error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 18, 1),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 18, 2),
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/diagnostics/for_in_of_invalid_element_type_test.dart b/pkg/analyzer/test/src/diagnostics/for_in_of_invalid_element_type_test.dart
index 916d47f..3875476 100644
--- a/pkg/analyzer/test/src/diagnostics/for_in_of_invalid_element_type_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/for_in_of_invalid_element_type_test.dart
@@ -17,28 +17,26 @@
 class ForInOfInvalidElementTypeTest extends PubPackageResolutionTest {
   test_await_declaredVariableWrongType() async {
     await assertErrorsInCode('''
-import 'dart:async';
 f() async {
   Stream<String> stream;
   await for (int i in stream) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 75, 1),
-      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 80, 6),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 54, 1),
+      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 59, 6),
     ]);
   }
 
   test_await_existingVariableWrongType() async {
     await assertErrorsInCode('''
-import 'dart:async';
 f() async {
   Stream<String> stream;
   int i;
   await for (i in stream) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 64, 1),
-      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 85, 6),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1),
+      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_ELEMENT_TYPE, 64, 6),
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/diagnostics/illegal_async_generator_return_type_test.dart b/pkg/analyzer/test/src/diagnostics/illegal_async_generator_return_type_test.dart
index ac52b34..c60b913 100644
--- a/pkg/analyzer/test/src/diagnostics/illegal_async_generator_return_type_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/illegal_async_generator_return_type_test.dart
@@ -31,11 +31,10 @@
 
   test_function_subtypeOfStream() async {
     await assertErrorsInCode('''
-import 'dart:async';
 abstract class SubStream<T> implements Stream<T> {}
 SubStream<int> f() async* {}
 ''', [
-      error(CompileTimeErrorCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, 73, 14),
+      error(CompileTimeErrorCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, 52, 14),
     ]);
   }
 
@@ -59,13 +58,12 @@
 
   test_method_subtypeOfStream() async {
     await assertErrorsInCode('''
-import 'dart:async';
 abstract class SubStream<T> implements Stream<T> {}
 class C {
   SubStream<int> f() async* {}
 }
 ''', [
-      error(CompileTimeErrorCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, 85, 14),
+      error(CompileTimeErrorCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, 64, 14),
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/diagnostics/illegal_async_return_type_test.dart b/pkg/analyzer/test/src/diagnostics/illegal_async_return_type_test.dart
index 3302326..01e30f0 100644
--- a/pkg/analyzer/test/src/diagnostics/illegal_async_return_type_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/illegal_async_return_type_test.dart
@@ -41,13 +41,12 @@
 
   test_function_subtypeOfFuture() async {
     await assertErrorsInCode('''
-import 'dart:async';
 abstract class SubFuture<T> implements Future<T> {}
 SubFuture<int> f() async {
   return 0;
 }
 ''', [
-      error(CompileTimeErrorCode.ILLEGAL_ASYNC_RETURN_TYPE, 73, 14),
+      error(CompileTimeErrorCode.ILLEGAL_ASYNC_RETURN_TYPE, 52, 14),
     ]);
   }
 
@@ -71,7 +70,6 @@
 
   test_method_subtypeOfFuture() async {
     await assertErrorsInCode('''
-import 'dart:async';
 abstract class SubFuture<T> implements Future<T> {}
 class C {
   SubFuture<int> m() async {
@@ -79,7 +77,7 @@
   }
 }
 ''', [
-      error(CompileTimeErrorCode.ILLEGAL_ASYNC_RETURN_TYPE, 85, 14),
+      error(CompileTimeErrorCode.ILLEGAL_ASYNC_RETURN_TYPE, 64, 14),
     ]);
   }
 }
diff --git a/pkg/analyzer/test/src/diagnostics/must_call_super_test.dart b/pkg/analyzer/test/src/diagnostics/must_call_super_test.dart
index 7a58e23..eda7bec 100644
--- a/pkg/analyzer/test/src/diagnostics/must_call_super_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/must_call_super_test.dart
@@ -170,7 +170,6 @@
   test_overriddenWithFuture() async {
     // https://github.com/flutter/flutter/issues/11646
     await assertNoErrorsInCode(r'''
-import 'dart:async';
 import 'package:meta/meta.dart';
 class A {
   @mustCallSuper
@@ -191,7 +190,6 @@
   test_overriddenWithFuture2() async {
     // https://github.com/flutter/flutter/issues/11646
     await assertNoErrorsInCode(r'''
-import 'dart:async';
 import 'package:meta/meta.dart';
 class A {
   @mustCallSuper
diff --git a/pkg/analyzer/test/src/diagnostics/not_assigned_potentially_non_nullable_local_variable_test.dart b/pkg/analyzer/test/src/diagnostics/not_assigned_potentially_non_nullable_local_variable_test.dart
index 1caa9cc..df5882b 100644
--- a/pkg/analyzer/test/src/diagnostics/not_assigned_potentially_non_nullable_local_variable_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/not_assigned_potentially_non_nullable_local_variable_test.dart
@@ -84,6 +84,8 @@
 }
 ''', [
       _notAssignedError(22, 1),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 28, 2),
       error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 28, 1),
     ]);
   }
@@ -96,6 +98,8 @@
 }
 ''', [
       _notAssignedError(22, 1),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 28, 2),
       error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 28, 1),
       _notAssignedError(28, 1),
     ]);
@@ -118,7 +122,11 @@
   (v = 0) ?? 0;
   v;
 }
-''', [error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 33, 1)]);
+''', [
+      error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 33, 1),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 33, 7),
+    ]);
   }
 
   test_binaryExpression_ifNull_right() async {
@@ -130,6 +138,8 @@
 }
 ''', [
       error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 32, 7),
+      // See https://github.com/dart-lang/sdk/issues/43263.
+      error(HintCode.DEAD_CODE, 32, 13),
       _notAssignedError(43, 1),
     ]);
   }
diff --git a/pkg/analyzer/test/src/diagnostics/return_in_generator_test.dart b/pkg/analyzer/test/src/diagnostics/return_in_generator_test.dart
index bdc49f3..748f963 100644
--- a/pkg/analyzer/test/src/diagnostics/return_in_generator_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/return_in_generator_test.dart
@@ -36,7 +36,6 @@
 
   test_asyncStar_blockBody_noValue() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Stream<int> f() async* {
   return;
 }
diff --git a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
index 0552343..a668a46 100644
--- a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
@@ -409,10 +409,4 @@
 int f() => A.x;
 ''');
   }
-
-  @override
-  @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/42957')
-  test_typeLiteral_conditionalAccess() {
-    return super.test_typeLiteral_conditionalAccess();
-  }
 }
diff --git a/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart b/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
index 862460e..f89e480 100644
--- a/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
@@ -19,15 +19,13 @@
   test_none_asyncStar_dynamic_to_streamInt() async {
     await assertErrorsInCode(
         '''
-import 'dart:async';
-
 Stream<int> f() async* {
   dynamic a = 0;
   yield a;
 }
 ''',
         expectedErrorsByNullability(nullable: [
-          error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 72, 1),
+          error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 50, 1),
         ], legacy: []));
   }
 
@@ -63,8 +61,6 @@
 
   test_none_asyncStar_int_to_streamDynamic() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 Stream f() async* {
   yield 0;
 }
@@ -73,8 +69,6 @@
 
   test_none_asyncStar_int_to_streamInt() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   yield 0;
 }
@@ -83,13 +77,11 @@
 
   test_none_asyncStar_int_to_streamString() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Stream<String> f() async* {
   yield 0;
 }
 ''', [
-      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 58, 1),
+      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 36, 1),
     ]);
   }
 
@@ -161,14 +153,12 @@
 
   test_none_syncStar_int_to_stream() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() sync* {
   yield 0;
 }
 ''', [
-      error(CompileTimeErrorCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, 22, 11),
-      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 54, 1),
+      error(CompileTimeErrorCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, 0, 11),
+      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 32, 1),
     ]);
   }
 
@@ -192,8 +182,6 @@
 
   test_star_asyncStar_dynamic_to_streamDynamic() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 Stream f() async* {
   yield* g();
 }
@@ -204,8 +192,6 @@
 
   test_star_asyncStar_dynamic_to_streamInt() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   yield* g();
 }
@@ -237,34 +223,28 @@
 
   test_star_asyncStar_iterableInt_to_streamInt() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   var a = <int>[];
   yield* a;
 }
 ''', [
-      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 75, 1),
+      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 53, 1),
     ]);
   }
 
   test_star_asyncStar_iterableString_to_streamInt() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   var a = <String>[];
   yield* a;
 }
 ''', [
-      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 78, 1),
+      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 56, 1),
     ]);
   }
 
   test_star_asyncStar_streamDynamic_to_dynamic() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 f() async* {
   yield* g();
 }
@@ -276,8 +256,6 @@
   test_star_asyncStar_streamDynamic_to_streamInt() async {
     await assertErrorsInCode(
         '''
-import 'dart:async';
-
 Stream<int> f() async* {
   yield* g();
 }
@@ -285,14 +263,12 @@
 Stream g() => throw 0;
 ''',
         expectedErrorsByNullability(nullable: [
-          error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 56, 3),
+          error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 34, 3),
         ], legacy: []));
   }
 
   test_star_asyncStar_streamInt_to_dynamic() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 f() async* {
   yield* g();
 }
@@ -303,8 +279,6 @@
 
   test_star_asyncStar_streamInt_to_streamInt() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   yield* g();
 }
@@ -315,15 +289,13 @@
 
   test_star_asyncStar_streamString_to_streamInt() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Stream<int> f() async* {
   yield* g();
 }
 
 Stream<String> g() => throw 0;
 ''', [
-      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 56, 3),
+      error(CompileTimeErrorCode.YIELD_OF_INVALID_TYPE, 34, 3),
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/task/strong/checker_test.dart b/pkg/analyzer/test/src/task/strong/checker_test.dart
index 366c696..41ea625 100644
--- a/pkg/analyzer/test/src/task/strong/checker_test.dart
+++ b/pkg/analyzer/test/src/task/strong/checker_test.dart
@@ -18,8 +18,6 @@
 class CheckerTest extends PubPackageResolutionTest {
   test_awaitForInCastsStreamElementToVariable() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 abstract class MyStream<T> extends Stream<T> {
   factory MyStream() => throw 0;
 }
@@ -41,12 +39,12 @@
   await for (int i in new MyStream<num>()) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 181, 1),
-      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_TYPE, 186, 4),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 235, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 309, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 373, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 438, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 159, 1),
+      error(CompileTimeErrorCode.FOR_IN_OF_INVALID_TYPE, 164, 4),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 213, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 287, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 351, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 416, 1),
     ]);
   }
 
@@ -1008,7 +1006,6 @@
 
   test_functionModifiers_async() async {
     await assertErrorsInCode('''
-import 'dart:async';
 import 'dart:math' show Random;
 
 dynamic x;
@@ -1053,13 +1050,13 @@
   return ((1 > 0) ? new Future<String>.value('hello') : "world");
 }
 ''', [
-      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 224, 27),
-      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 454, 27),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 529, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 548, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 567, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 589, 1),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 593, 7),
+      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 203, 27),
+      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 433, 27),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 508, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 527, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 546, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 568, 1),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 572, 7),
     ]);
   }
 
diff --git a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
index 6c8f375..b7e1600 100644
--- a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
+++ b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
@@ -28,7 +28,6 @@
 
   test_asyncClosureReturnType_flatten() async {
     await assertNoErrorsInCode('''
-import 'dart:async';
 Future<int> futureInt = null;
 var f = () => futureInt;
 var g = () async => futureInt;
@@ -73,7 +72,6 @@
 
   test_blockBodiedLambdas_async_allReturnsAreFutures() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 import 'dart:math' show Random;
 main() {
   var f = () async {
@@ -87,8 +85,8 @@
   Future<int> h = f();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 239, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 262, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 218, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 241, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -97,7 +95,6 @@
 
   test_blockBodiedLambdas_async_allReturnsAreValues() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 import 'dart:math' show Random;
 main() {
   var f = () async {
@@ -111,8 +108,8 @@
   Future<int> h = f();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 190, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 213, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 169, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 192, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -121,7 +118,6 @@
 
   test_blockBodiedLambdas_async_mixOfValuesAndFutures() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 import 'dart:math' show Random;
 main() {
   var f = () async {
@@ -135,8 +131,8 @@
   Future<int> h = f();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 213, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 236, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 192, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 215, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -145,7 +141,6 @@
 
   test_blockBodiedLambdas_asyncStar() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 main() {
   var f = () async* {
     yield 1;
@@ -156,8 +151,8 @@
   Stream<int> h = f();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 120, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 143, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 99, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 122, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -203,7 +198,6 @@
 
   test_blockBodiedLambdas_inferBottom_async() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 main() async {
   var f = () async { return null; };
   Future y = f();
@@ -211,9 +205,9 @@
   String s = await f();
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 82, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 108, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 126, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 87, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 105, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -222,7 +216,6 @@
 
   test_blockBodiedLambdas_inferBottom_asyncStar() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 main() async {
   var f = () async* { yield null; };
   Stream y = f();
@@ -230,9 +223,9 @@
   String s = await f().first;
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 82, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 108, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 126, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 87, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 105, 1),
     ]);
 
     var f = findLocalVariable(_resultUnit, 'f');
@@ -844,22 +837,19 @@
 
   test_downwardsInferenceAsyncAwait() async {
     await assertErrorsInCode('''
-import 'dart:async';
 Future test() async {
   dynamic d;
   List<int> l0 = await [d];
   List<int> l1 = await new Future.value([d]);
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 68, 2),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 96, 2),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 47, 2),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 75, 2),
     ]);
   }
 
   test_downwardsInferenceForEach() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 abstract class MyStream<T> extends Stream<T> {
   factory MyStream() => throw 0;
 }
@@ -869,8 +859,8 @@
   await for(int x in new MyStream()) {}
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 137, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 172, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 115, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 150, 1),
     ]);
   }
 
@@ -1689,7 +1679,6 @@
 
   test_futureOr_subtyping() async {
     await assertErrorsInCode(r'''
-import 'dart:async';
 void add(int x) {}
 add2(int y) {}
 main() {
@@ -1698,14 +1687,15 @@
   var b = f.then(add2);
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 87, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 110, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 66, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 89, 1),
     ]);
   }
 
   test_futureThen() async {
     String build({String declared, String downwards, String upwards}) => '''
 import 'dart:async';
+
 class MyFuture<T> implements Future<T> {
   MyFuture() {}
   MyFuture.value(T x) {}
@@ -1793,7 +1783,6 @@
   test_futureThen_downwardsMethodTarget() async {
     // Not working yet, see: https://github.com/dart-lang/sdk/issues/27114
     await assertErrorsInCode(r'''
-import 'dart:async';
 main() {
   Future<int> f;
   Future<List<int>> b = f
@@ -1802,13 +1791,12 @@
   b = f.then((x) => []);
 }
   ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 67, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 46, 1),
     ]);
   }
 
   test_futureThen_explicitFuture() async {
     await assertErrorsInCode(r'''
-import "dart:async";
 m1() {
   Future<int> f;
   var x = f.then<Future<List<int>>>((x) => []);
@@ -1820,10 +1808,10 @@
   Future<List<int>> y = x;
 }
 ''', [
-      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE, 88, 2),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 113, 1),
-      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 117, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 206, 1),
+      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE, 67, 2),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 92, 1),
+      error(CompileTimeErrorCode.INVALID_ASSIGNMENT, 96, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 185, 1),
     ]);
   }
 
@@ -1887,7 +1875,6 @@
   test_futureThen_upwardsFromBlock() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/27113.
     await assertErrorsInCode(r'''
-import 'dart:async';
 main() {
   Future<int> base;
   var f = base.then((x) { return x == 0; });
@@ -1896,7 +1883,7 @@
   b = g;
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 146, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 125, 1),
     ]);
   }
 
@@ -2018,8 +2005,6 @@
     // We need to take a future union into account for both directions of
     // generic method inference.
     await assertErrorsInCode(r'''
-import 'dart:async';
-
 foo() async {
   Future<List<A>> f1 = null;
   Future<List<A>> f2 = null;
@@ -2028,15 +2013,13 @@
 
 class A {}
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 110, 6),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 88, 6),
     ]);
   }
 
   test_futureUnion_downwardsGenericMethodWithGenericReturn() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/27284
     await assertErrorsInCode(r'''
-import 'dart:async';
-
 T id<T>(T x) => x;
 
 main() async {
@@ -2044,15 +2027,13 @@
   String s = await id(f);
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 86, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 64, 1),
     ]);
   }
 
   test_futureUnion_upwardsGenericMethods() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/27151
     await assertErrorsInCode(r'''
-import 'dart:async';
-
 main() async {
   var b = new Future<B>.value(new B());
   var c = new Future<C>.value(new C());
@@ -2067,7 +2048,7 @@
 class B extends A {}
 class C extends A {}
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 229, 4),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 207, 4),
     ]);
   }
 
@@ -2287,8 +2268,6 @@
 
   test_genericMethods_IterableAndFuture() async {
     await assertErrorsInCode('''
-import 'dart:async';
-
 Future<int> make(int x) => (new Future(() => x));
 
 main() {
@@ -2304,11 +2283,11 @@
     => list.fold<String>('', (x, y) => x + y.toString()));
 }
 ''', [
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 205, 8),
-      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 279, 1),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 315, 8),
-      error(CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 377, 33),
-      error(HintCode.UNUSED_LOCAL_VARIABLE, 432, 8),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 183, 8),
+      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 257, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 293, 8),
+      error(CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 355, 33),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 410, 8),
     ]);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 74b894e..ec7bc61 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -1159,7 +1159,8 @@
             lhsResult.inferredType, equalsName, node.fileOffset)
         .member;
 
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(node.left);
+    inferrer.flowAnalysis
+        .ifNullExpression_rightBegin(node.left, lhsResult.inferredType);
     // - Let J = T0 if K is `?` else K.
     // - Infer e1 in context J to get T1
     ExpressionInferenceResult rhsResult;
@@ -2670,7 +2671,7 @@
     Expression read = readResult.expression;
     DartType readType = readResult.inferredType;
 
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
     ExpressionInferenceResult writeResult = inferrer
         .inferExpression(node.write, typeContext, true, isVoidAllowed: true);
     inferrer.flowAnalysis.ifNullExpression_end();
@@ -2742,7 +2743,7 @@
       read = readResult.expression;
       readType = readResult.inferredType;
     }
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
     ExpressionInferenceResult writeResult = inferrer
         .inferExpression(node.write, typeContext, true, isVoidAllowed: true);
     inferrer.flowAnalysis.ifNullExpression_end();
@@ -3098,7 +3099,7 @@
         readResult.inferredType, "??=", node.readOffset);
     Expression read = readResult.expression;
     DartType readType = readResult.inferredType;
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
 
     Member equalsMember = inferrer
         .findInterfaceMember(readType, equalsName, node.testOffset)
@@ -3269,7 +3270,7 @@
         ..fileOffset = node.readOffset;
     }
 
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
     ExpressionInferenceResult valueResult = inferrer
         .inferExpression(node.value, valueType, true, isVoidAllowed: true);
     Expression value = inferrer.ensureAssignableResult(valueType, valueResult);
@@ -3423,7 +3424,7 @@
         readResult.inferredType, "??=", node.readOffset);
     Expression read = readResult.expression;
     DartType readType = readResult.inferredType;
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
 
     Member equalsMember = inferrer
         .findInterfaceMember(readType, equalsName, node.testOffset)
@@ -4903,7 +4904,7 @@
         isThisReceiver: node.receiver is ThisExpression);
     Expression read = readResult.expression;
     DartType readType = readResult.inferredType;
-    inferrer.flowAnalysis.ifNullExpression_rightBegin(read);
+    inferrer.flowAnalysis.ifNullExpression_rightBegin(read, readType);
 
     Member readEqualsMember = inferrer
         .findInterfaceMember(readType, equalsName, node.testOffset)
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 0603833..2d855ee8 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -3814,14 +3814,15 @@
         assert(_inferrer != null) {
     // Ensure the initializer of [_nullAwareVariable] is promoted to
     // non-nullable.
-    _inferrer.flowAnalysis
-        .nullAwareAccess_rightBegin(_nullAwareVariable.initializer);
+    _inferrer.flowAnalysis.nullAwareAccess_rightBegin(
+        _nullAwareVariable.initializer, _nullAwareVariable.type);
     // Ensure [_nullAwareVariable] is promoted to non-nullable.
     // TODO(johnniwinther): Avoid creating a [VariableGet] to promote the
     // variable.
     VariableGet read = new VariableGet(_nullAwareVariable);
     _inferrer.flowAnalysis.variableRead(read, _nullAwareVariable);
-    _inferrer.flowAnalysis.nullAwareAccess_rightBegin(read);
+    _inferrer.flowAnalysis
+        .nullAwareAccess_rightBegin(read, _nullAwareVariable.type);
   }
 
   /// Creates the null-guarded application of [nullAwareAction] with the
diff --git a/pkg/front_end/test/spell_checking_list_common.txt b/pkg/front_end/test/spell_checking_list_common.txt
index 81e9982..c9f67ed 100644
--- a/pkg/front_end/test/spell_checking_list_common.txt
+++ b/pkg/front_end/test/spell_checking_list_common.txt
@@ -276,6 +276,7 @@
 behaviors
 behind
 being
+believes
 belong
 belongs
 below
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index c61bc53..b59c9c5 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -456,7 +456,7 @@
     } else if (operatorType == TokenType.QUESTION_QUESTION) {
       DecoratedType expressionType;
       var leftType = _dispatch(leftOperand);
-      _flowAnalysis.ifNullExpression_rightBegin(node.leftOperand);
+      _flowAnalysis.ifNullExpression_rightBegin(node.leftOperand, leftType);
       try {
         _guards.add(leftType.node);
         DecoratedType rightType;
@@ -2210,8 +2210,8 @@
 
     if (questionAssignNode != null) {
       _guards.add(destinationType.node);
-      _flowAnalysis
-          .ifNullExpression_rightBegin(questionAssignNode.leftHandSide);
+      _flowAnalysis.ifNullExpression_rightBegin(
+          questionAssignNode.leftHandSide, destinationType);
     }
     DecoratedType sourceType;
     try {
diff --git a/runtime/bin/file_win.cc b/runtime/bin/file_win.cc
index 848036a..21f8df2 100644
--- a/runtime/bin/file_win.cc
+++ b/runtime/bin/file_win.cc
@@ -886,15 +886,22 @@
     result = kDoesNotExist;
   } else if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (follow_links) {
-      HANDLE dir_handle =
+      HANDLE target_handle =
           CreateFileW(name.wide(), 0,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-      if (dir_handle == INVALID_HANDLE_VALUE) {
+      if (target_handle == INVALID_HANDLE_VALUE) {
         result = File::kIsLink;
       } else {
-        CloseHandle(dir_handle);
-        result = File::kIsDirectory;
+        BY_HANDLE_FILE_INFORMATION info;
+        if (!GetFileInformationByHandle(target_handle, &info)) {
+          CloseHandle(target_handle);
+          return File::kIsLink;
+        }
+        CloseHandle(target_handle);
+        return ((info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
+                   ? File::kIsDirectory
+                   : File::kIsFile;
       }
     } else {
       result = kIsLink;
diff --git a/tests/language/constructor/missing_initializer_test.dart b/tests/language/constructor/missing_initializer_test.dart
index 3604aa8..3736c5f 100644
--- a/tests/language/constructor/missing_initializer_test.dart
+++ b/tests/language/constructor/missing_initializer_test.dart
@@ -32,6 +32,8 @@
 }
 
 class C = Object with A;
+  //  ^
+  // [analyzer] COMPILE_TIME_ERROR.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER
 
 // Has a generative constructor: default.
 abstract class D {
diff --git a/tests/language/nnbd/const/regress43281_test.dart b/tests/language/nnbd/const/regress43281_test.dart
new file mode 100644
index 0000000..e2a400a
--- /dev/null
+++ b/tests/language/nnbd/const/regress43281_test.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2020, 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:expect/expect.dart';
+
+// Regression test for https://github.com/dart-lang/sdk/issues/43281.
+
+void main() {
+  const s = {1, 2, 3, null};
+  Expect.equals(4, s.length);
+  Expect.isTrue(s is Set<int?>);
+}
diff --git a/tests/standalone/io/windows_file_system_links_test.dart b/tests/standalone/io/windows_file_system_links_test.dart
index ccf38e5..dcbc571 100644
--- a/tests/standalone/io/windows_file_system_links_test.dart
+++ b/tests/standalone/io/windows_file_system_links_test.dart
@@ -2,9 +2,9 @@
 // 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:expect/expect.dart';
 import "dart:io";
-import "dart:isolate";
+
+import 'package:expect/expect.dart';
 
 testJunctionTypeDelete() {
   var temp =
@@ -75,9 +75,57 @@
   });
 }
 
+void testLinkToFile() {
+  final temp =
+      Directory.systemTemp.createTempSync('dart_windows_file_system_links');
+  // Create file
+  File file = new File(temp.path + Platform.pathSeparator + "test-file.tmp");
+  file.createSync();
+  // Create link pointing to the file above
+  Link link = new Link(temp.path + Platform.pathSeparator + "test-link.lnk");
+  link.createSync(file.path);
+
+  Link link2 = new Link(temp.path + Platform.pathSeparator + "test-link2.lnk");
+  link2.createSync(link.path);
+
+  try {
+    Expect.isTrue(FileSystemEntity.isLinkSync(link.path));
+    Expect.isTrue(FileSystemEntity.isLinkSync(link2.path));
+    Expect.isTrue(FileSystemEntity.isFileSync(link2.path));
+    Expect.isFalse(FileSystemEntity.isDirectorySync(link2.path));
+  } finally {
+    temp.deleteSync(recursive: true);
+  }
+}
+
+void testLinkToDirectory() {
+  final temp =
+      Directory.systemTemp.createTempSync('dart_windows_file_system_links');
+  // Create file
+  Directory dir = Directory(temp.path + Platform.pathSeparator + "test-dir");
+  dir.createSync();
+  // Create link pointing to the file above
+  Link link = Link(temp.path + Platform.pathSeparator + "test-link.lnk");
+  link.createSync(dir.path);
+
+  Link link2 = Link(temp.path + Platform.pathSeparator + "test-link2.lnk");
+  link2.createSync(link.path);
+
+  try {
+    Expect.isTrue(FileSystemEntity.isLinkSync(link.path));
+    Expect.isTrue(FileSystemEntity.isLinkSync(link2.path));
+    Expect.isFalse(FileSystemEntity.isFileSync(link2.path));
+    Expect.isTrue(FileSystemEntity.isDirectorySync(link2.path));
+  } finally {
+    temp.deleteSync(recursive: true);
+  }
+}
+
 main() {
   // Links on other platforms are tested by file_system_[async_]links_test.
   if (Platform.operatingSystem == 'windows') {
     testJunctionTypeDelete();
+    testLinkToFile();
+    testLinkToDirectory();
   }
 }
diff --git a/tests/standalone_2/io/windows_file_system_links_test.dart b/tests/standalone_2/io/windows_file_system_links_test.dart
index ccf38e5..dcbc571 100644
--- a/tests/standalone_2/io/windows_file_system_links_test.dart
+++ b/tests/standalone_2/io/windows_file_system_links_test.dart
@@ -2,9 +2,9 @@
 // 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:expect/expect.dart';
 import "dart:io";
-import "dart:isolate";
+
+import 'package:expect/expect.dart';
 
 testJunctionTypeDelete() {
   var temp =
@@ -75,9 +75,57 @@
   });
 }
 
+void testLinkToFile() {
+  final temp =
+      Directory.systemTemp.createTempSync('dart_windows_file_system_links');
+  // Create file
+  File file = new File(temp.path + Platform.pathSeparator + "test-file.tmp");
+  file.createSync();
+  // Create link pointing to the file above
+  Link link = new Link(temp.path + Platform.pathSeparator + "test-link.lnk");
+  link.createSync(file.path);
+
+  Link link2 = new Link(temp.path + Platform.pathSeparator + "test-link2.lnk");
+  link2.createSync(link.path);
+
+  try {
+    Expect.isTrue(FileSystemEntity.isLinkSync(link.path));
+    Expect.isTrue(FileSystemEntity.isLinkSync(link2.path));
+    Expect.isTrue(FileSystemEntity.isFileSync(link2.path));
+    Expect.isFalse(FileSystemEntity.isDirectorySync(link2.path));
+  } finally {
+    temp.deleteSync(recursive: true);
+  }
+}
+
+void testLinkToDirectory() {
+  final temp =
+      Directory.systemTemp.createTempSync('dart_windows_file_system_links');
+  // Create file
+  Directory dir = Directory(temp.path + Platform.pathSeparator + "test-dir");
+  dir.createSync();
+  // Create link pointing to the file above
+  Link link = Link(temp.path + Platform.pathSeparator + "test-link.lnk");
+  link.createSync(dir.path);
+
+  Link link2 = Link(temp.path + Platform.pathSeparator + "test-link2.lnk");
+  link2.createSync(link.path);
+
+  try {
+    Expect.isTrue(FileSystemEntity.isLinkSync(link.path));
+    Expect.isTrue(FileSystemEntity.isLinkSync(link2.path));
+    Expect.isFalse(FileSystemEntity.isFileSync(link2.path));
+    Expect.isTrue(FileSystemEntity.isDirectorySync(link2.path));
+  } finally {
+    temp.deleteSync(recursive: true);
+  }
+}
+
 main() {
   // Links on other platforms are tested by file_system_[async_]links_test.
   if (Platform.operatingSystem == 'windows') {
     testJunctionTypeDelete();
+    testLinkToFile();
+    testLinkToDirectory();
   }
 }
diff --git a/tools/VERSION b/tools/VERSION
index ba3ae6a..b464eb3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 10
 PATCH 0
-PRERELEASE 91
+PRERELEASE 92
 PRERELEASE_PATCH 0
\ No newline at end of file