Flow analysis: implement "why not promoted" logic for most binary operators.

`&&` and `||` will be addressed in a follow-up CL go through a
different code path in the analyzer.

Bug: #44898
Change-Id: I20732ceceb113017a0b1e77134b1e28c4c924fbb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/192607
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -4184,10 +4184,13 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
 
   @override
   Map<Type, NonPromotionReason> Function() whyNotPromoted(Expression target) {
-    ReferenceWithType<Variable, Type>? referenceWithType = _expressionReference;
-    if (referenceWithType != null) {
-      return referenceWithType.reference.getNonPromotionReasons(
-          _current.variableInfo, referenceWithType.type, typeOperations);
+    if (identical(target, _expressionWithReference)) {
+      ReferenceWithType<Variable, Type>? referenceWithType =
+          _expressionReference;
+      if (referenceWithType != null) {
+        return referenceWithType.reference.getNonPromotionReasons(
+            _current.variableInfo, referenceWithType.type, typeOperations);
+      }
     }
     return () => {};
   }

pkg/_fe_analyzer_shared/test/flow_analysis/why_not_promoted/data/argument_type_not_assignable_nullability_error.dart

@@ -89,3 +89,46 @@ C7 constructor_with_explicit_new(C7 c) {
       /*analyzer.notPromoted(propertyNotPromoted(target: member:C7.bad, type: int?))*/ c
           . /*cfe.notPromoted(propertyNotPromoted(target: member:C7.bad, type: int?))*/ bad);
 }
+
+class C8 {
+  int? bad;
+}
+
+userDefinableBinaryOpRhs(C8 c) {
+  if (c.bad == null) return;
+  1 +
+      /*analyzer.notPromoted(propertyNotPromoted(target: member:C8.bad, type: int?))*/ c
+          . /*cfe.notPromoted(propertyNotPromoted(target: member:C8.bad, type: int?))*/ bad;
+}
+
+class C9 {
+  int? bad;
+  f(int i) {}
+}
+
+questionQuestionRhs(C9 c, int? i) {
+  // Note: "why not supported" functionality is currently not supported for the
+  // RHS of `??` because it requires more clever reasoning than we currently do:
+  // we would have to understand that the reason `i ?? c.bad` has a type of
+  // `int?` rather than `int` is because `c.bad` was not promoted.  We currently
+  // only support detecting non-promotion when the expression that had the wrong
+  // type *is* the expression that wasn't promoted.
+  if (c.bad == null) return;
+  c.f(i ?? c.bad);
+}
+
+class C10 {
+  D10? bad;
+  f(bool b) {}
+}
+
+class D10 {
+  bool operator ==(covariant D10 other) => true;
+}
+
+equalRhs(C10 c, D10 d) {
+  if (c.bad == null) return;
+  // Note: we don't report an error here because `==` always accepts `null`.
+  c.f(d == c.bad);
+  c.f(d != c.bad);
+}

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

@@ -108,6 +108,8 @@ class BinaryExpressionResolver {
     var right = node.rightOperand;
     right.accept(_resolver);
     right = node.rightOperand;
+    var whyNotPromotedInfo =
+        _resolver.flowAnalysis?.flow?.whyNotPromoted(right);
 
     if (!leftExtensionOverride) {
       flow?.equalityOp_end(node, right, right.typeOrThrow, notEqual: notEqual);
@@ -119,6 +121,9 @@ class BinaryExpressionResolver {
       promoteLeftTypeToNonNull: true,
     );
     _resolveUserDefinableType(node);
+    _resolver.checkForArgumentTypeNotAssignableForArgument(node.rightOperand,
+        promoteParameterToNullable: true,
+        whyNotPromotedInfo: whyNotPromotedInfo);
   }
 
   void _resolveIfNull(BinaryExpressionImpl node) {
@@ -154,6 +159,7 @@ class BinaryExpressionResolver {
     } else {
       _analyzeLeastUpperBoundTypes(node, leftType, rightType);
     }
+    _resolver.checkForArgumentTypeNotAssignableForArgument(right);
   }
 
   void _resolveLogicalAnd(BinaryExpressionImpl node) {
@@ -259,8 +265,13 @@ class BinaryExpressionResolver {
     }
 
     right.accept(_resolver);
+    right = node.rightOperand;
+    var whyNotPromotedInfo =
+        _resolver.flowAnalysis?.flow?.whyNotPromoted(right);
 
     _resolveUserDefinableType(node);
+    _resolver.checkForArgumentTypeNotAssignableForArgument(right,
+        whyNotPromotedInfo: whyNotPromotedInfo);
   }
 
   void _resolveUserDefinableElement(

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

@@ -388,13 +388,8 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     TokenType type = operator.type;
     if (type == TokenType.AMPERSAND_AMPERSAND || type == TokenType.BAR_BAR) {
       checkForUseOfVoidResult(node.rightOperand);
-    } else if (type == TokenType.EQ_EQ || type == TokenType.BANG_EQ) {
-      checkForArgumentTypeNotAssignableForArgument(node.rightOperand,
-          promoteParameterToNullable: true);
-    } else if (type != TokenType.QUESTION_QUESTION) {
-      checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
     } else {
-      checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
+      // Assignability checking is done by the resolver.
     }
 
     if (type == TokenType.QUESTION_QUESTION) {

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

@@ -1837,6 +1837,10 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
   void visitNamedExpression(NamedExpression node) {
     InferenceContext.setTypeFromNode(node.expression, node);
     super.visitNamedExpression(node);
+    // Any "why not promoted" information that flow analysis had associated with
+    // `node.expression` now needs to be forwarded to `node`, so that when
+    // `visitArgumentList` iterates through the arguments, it will find it.
+    flowAnalysis?.flow?.forwardExpression(node, node.expression);
   }
 
   @override