Flow analysis: add support for non-null assertion operator.

Change-Id: I7a60944a4389b6f7c8e182d5c9b402fcbb05b624
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/121100
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: stereotype441

pkg/analyzer/lib/src/generated/resolver.dart

@@ -4348,6 +4348,15 @@ class ResolverVisitor extends ScopedVisitor {
     _flowAnalysis?.flow?.parenthesizedExpression(node, node.expression);
   }
 
+  @override
+  void visitPostfixExpression(PostfixExpression node) {
+    super.visitPostfixExpression(node);
+
+    if (node.operator.type == TokenType.BANG) {
+      _flowAnalysis?.flow?.nonNullAssert_end(node.operand);
+    }
+  }
+
   @override
   void visitPrefixedIdentifier(PrefixedIdentifier node) {
     //

pkg/front_end/lib/src/fasta/flow_analysis/flow_analysis.dart

@@ -543,6 +543,16 @@ class FlowAnalysis<Statement, Expression, Variable, Type> {
             conditionInfo._ifTrue));
   }
 
+  /// Call this method just after visiting a non-null assertion (`x!`)
+  /// expression.
+  void nonNullAssert_end(Expression operand) {
+    _ExpressionInfo<Variable, Type> operandInfo = _getExpressionInfo(operand);
+    if (operandInfo is _VariableReadInfo<Variable, Type>) {
+      _current =
+          _current.markNonNullable(typeOperations, operandInfo._variable);
+    }
+  }
+
   /// Call this method when encountering an expression that is a `null` literal.
   void nullLiteral(Expression expression) {
     _storeExpressionInfo(expression, new _NullInfo(_current));
@@ -730,7 +740,9 @@ class FlowAnalysis<Statement, Expression, Variable, Type> {
   /// returned.
   _ExpressionInfo<Variable, Type> _getExpressionInfo(Expression expression) {
     if (identical(expression, _expressionWithInfo)) {
-      return _expressionInfo;
+      _ExpressionInfo<Variable, Type> expressionInfo = _expressionInfo;
+      _expressionInfo = null;
+      return expressionInfo;
     } else {
       return null;
     }

pkg/front_end/test/fasta/flow_analysis/flow_analysis_test.dart

@@ -768,6 +768,18 @@ main() {
       });
     });
 
+    test('nonNullAssert_end(x) promotes', () {
+      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.nonNullAssert_end(varExpr);
+        expect(flow.promotedType(x).type, 'int');
+      });
+    });
+
     test('parenthesizedExpression preserves promotion behaviors', () {
       var h = _Harness();
       var x = h.addVar('x', 'int?');

pkg/front_end/test/flow_analysis/nullability/data/null_check.dart

@@ -0,0 +1,8 @@
+// Copyright (c) 2019, 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 bang_promotes(int? x) {
+  x!;
+  /*nonNullable*/ x;
+}

pkg/nnbd_migration/lib/src/fix_builder.dart

@@ -277,6 +277,7 @@ abstract class FixBuilder extends GeneralizingAstVisitor<DartType> {
       var type = subexpression.accept(this);
       if (_doesAssignmentNeedCheck(from: type, to: contextType)) {
         addNullCheck(subexpression);
+        _flowAnalysis.nonNullAssert_end(subexpression);
         return _typeSystem.promoteToNonNull(type as TypeImpl);
       } else {
         return type;

pkg/nnbd_migration/test/fix_builder_test.dart

@@ -529,6 +529,16 @@ f() => 1;
     visitSubexpression(findNode.integerLiteral('1'), 'int');
   }
 
+  test_nullAssertion_promotes() async {
+    await analyze('''
+_f(bool/*?*/ x) => x && x;
+''');
+    // Only the first `x` is null-checked because thereafter, the type of `x` is
+    // promoted to `bool`.
+    visitSubexpression(findNode.binary('&&'), 'bool',
+        nullChecked: {findNode.simple('x &&')});
+  }
+
   test_nullLiteral() async {
     await analyze('''
 f() => null;