Flow analysis: unify API for handling == null and != null.

This reduces code duplication in the client.

Change-Id: I278fb4d3c7fc7b913498d4a69f4f361f6227da32
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/112146
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>

Author: stereotype441

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

@@ -11,6 +11,7 @@ import 'package:analyzer/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/variable_type_provider.dart';
 import 'package:front_end/src/fasta/flow_analysis/flow_analysis.dart';
+import 'package:meta/meta.dart';
 
 class AnalyzerFunctionBodyAccess
     implements FunctionBodyAccess<VariableElement> {
@@ -104,49 +105,23 @@ class FlowAnalysisHelper {
     flow.write(localElement);
   }
 
-  void binaryExpression_bangEq(
-    BinaryExpression node,
-    Expression left,
-    Expression right,
-  ) {
+  void binaryExpression_equal(
+      BinaryExpression node, Expression left, Expression right,
+      {@required bool notEqual}) {
     if (flow == null) return;
 
     if (right is NullLiteral) {
       if (left is SimpleIdentifier) {
         var element = left.staticElement;
         if (element is VariableElement) {
-          flow.conditionNotEqNull(node, element);
+          flow.conditionEqNull(node, element, notEqual: notEqual);
         }
       }
     } else if (left is NullLiteral) {
       if (right is SimpleIdentifier) {
         var element = right.staticElement;
         if (element is VariableElement) {
-          flow.conditionNotEqNull(node, element);
-        }
-      }
-    }
-  }
-
-  void binaryExpression_eqEq(
-    BinaryExpression node,
-    Expression left,
-    Expression right,
-  ) {
-    if (flow == null) return;
-
-    if (right is NullLiteral) {
-      if (left is SimpleIdentifier) {
-        var element = left.staticElement;
-        if (element is VariableElement) {
-          flow.conditionEqNull(node, element);
-        }
-      }
-    } else if (left is NullLiteral) {
-      if (right is SimpleIdentifier) {
-        var element = right.staticElement;
-        if (element is VariableElement) {
-          flow.conditionEqNull(node, element);
+          flow.conditionEqNull(node, element, notEqual: notEqual);
         }
       }
     }

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

@@ -3449,16 +3449,12 @@ class ResolverVisitor extends ScopedVisitor {
       flow?.logicalOr_end(node, right);
 
       node.accept(elementResolver);
-    } else if (operator == TokenType.BANG_EQ) {
+    } else if (operator == TokenType.BANG_EQ || operator == TokenType.EQ_EQ) {
       left.accept(this);
       right.accept(this);
       node.accept(elementResolver);
-      _flowAnalysis?.binaryExpression_bangEq(node, left, right);
-    } else if (operator == TokenType.EQ_EQ) {
-      left.accept(this);
-      right.accept(this);
-      node.accept(elementResolver);
-      _flowAnalysis?.binaryExpression_eqEq(node, left, right);
+      _flowAnalysis?.binaryExpression_equal(node, left, right,
+          notEqual: operator == TokenType.BANG_EQ);
     } else {
       if (operator == TokenType.QUESTION_QUESTION) {
         InferenceContext.setTypeFromNode(left, node);

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

@@ -187,28 +187,24 @@ class FlowAnalysis<Statement, Expression, Variable, Type> {
     _current = trueCondition;
   }
 
-  /// The [binaryExpression] checks that the [variable] is equal to `null`.
-  void conditionEqNull(Expression binaryExpression, Variable variable) {
+  /// The [binaryExpression] checks that the [variable] is, or is not, equal to
+  /// `null`.
+  void conditionEqNull(Expression binaryExpression, Variable variable,
+      {bool notEqual: false}) {
     _variableReferenced(variable);
     if (functionBody.isPotentiallyMutatedInClosure(variable)) {
       return;
     }
 
     _condition = binaryExpression;
-    _conditionTrue = _current;
-    _conditionFalse = _current.markNonNullable(typeOperations, variable);
-  }
-
-  /// The [binaryExpression] checks that the [variable] is not equal to `null`.
-  void conditionNotEqNull(Expression binaryExpression, Variable variable) {
-    _variableReferenced(variable);
-    if (functionBody.isPotentiallyMutatedInClosure(variable)) {
-      return;
+    var currentPromoted = _current.markNonNullable(typeOperations, variable);
+    if (notEqual) {
+      _conditionTrue = currentPromoted;
+      _conditionFalse = _current;
+    } else {
+      _conditionTrue = _current;
+      _conditionFalse = currentPromoted;
     }
-
-    _condition = binaryExpression;
-    _conditionTrue = _current.markNonNullable(typeOperations, variable);
-    _conditionFalse = _current;
   }
 
   void doStatement_bodyBegin(

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

@@ -7,11 +7,11 @@ import 'package:test/test.dart';
 
 main() {
   group('API', () {
-    test('conditionNotEqNull promotes true branch', () {
+    test('conditionEqNull(notEqual: true) promotes true branch', () {
       var h = _Harness();
       var x = h.addAssignedVar('x', 'int?');
       var expr = _Expression();
-      h.flow.conditionNotEqNull(expr, x);
+      h.flow.conditionEqNull(expr, x, notEqual: true);
       h.flow.ifStatement_thenBegin(expr);
       expect(h.flow.promotedType(x).type, 'int');
       h.flow.ifStatement_elseBegin();
@@ -20,11 +20,11 @@ main() {
       h.flow.finish();
     });
 
-    test('conditionEqNull promotes false branch', () {
+    test('conditionEqNull(notEqual: false) promotes false branch', () {
       var h = _Harness();
       var x = h.addAssignedVar('x', 'int?');
       var expr = _Expression();
-      h.flow.conditionEqNull(expr, x);
+      h.flow.conditionEqNull(expr, x, notEqual: false);
       h.flow.ifStatement_thenBegin(expr);
       expect(h.flow.promotedType(x), isNull);
       h.flow.ifStatement_elseBegin();