Share checkForInvalidAssignment betwen resolver and ErrorVerifier.

In order to implement "why not promoted" functionality for variable
declaration initializers, we will need to call
checkForInvalidAssignment from the resolver, so that we can pass it
failed promotion information.  So move it into the
ErrorDetectionHelpers mixin, along with _checkForAssignableExpression
(which it calls).

_checkForAssignableExpressionAtType can now be private, since all of
its callers are now in ErrorDetectionHelpers.

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

Author: stereotype441

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

@@ -39,7 +39,7 @@ mixin ErrorDetectionHelpers {
         return;
       }
 
-      checkForAssignableExpressionAtType(
+      _checkForAssignableExpressionAtType(
           expression, actualStaticType, expectedStaticType, errorCode,
           whyNotPromotedInfo: whyNotPromotedInfo);
     }
@@ -81,33 +81,41 @@ mixin ErrorDetectionHelpers {
         whyNotPromotedInfo);
   }
 
-  bool checkForAssignableExpressionAtType(
-      Expression expression,
-      DartType actualStaticType,
-      DartType expectedStaticType,
-      ErrorCode errorCode,
-      {Map<DartType, NonPromotionReason> Function()? whyNotPromotedInfo}) {
-    if (!typeSystem.isAssignableTo(actualStaticType, expectedStaticType)) {
-      AstNode getErrorNode(AstNode node) {
-        if (node is CascadeExpression) {
-          return getErrorNode(node.target);
-        }
-        if (node is ParenthesizedExpression) {
-          return getErrorNode(node.expression);
-        }
-        return node;
-      }
+  /// Verify that the given left hand side ([lhs]) and right hand side ([rhs])
+  /// represent a valid assignment.
+  ///
+  /// See [CompileTimeErrorCode.INVALID_ASSIGNMENT].
+  void checkForInvalidAssignment(Expression? lhs, Expression? rhs) {
+    if (lhs == null || rhs == null) {
+      return;
+    }
 
-      errorReporter.reportErrorForNode(
-        errorCode,
-        getErrorNode(expression),
-        [actualStaticType, expectedStaticType],
-        computeWhyNotPromotedMessages(
-            expression, expression, whyNotPromotedInfo?.call()),
-      );
-      return false;
+    if (lhs is IndexExpression &&
+            identical(lhs.realTarget.staticType, NeverTypeImpl.instance) ||
+        lhs is PrefixedIdentifier &&
+            identical(lhs.prefix.staticType, NeverTypeImpl.instance) ||
+        lhs is PropertyAccess &&
+            identical(lhs.realTarget.staticType, NeverTypeImpl.instance)) {
+      return;
     }
-    return true;
+
+    DartType leftType;
+    var parent = lhs.parent;
+    if (parent is AssignmentExpression && parent.leftHandSide == lhs) {
+      leftType = parent.writeType!;
+    } else {
+      var leftVariableElement = getVariableElement(lhs);
+      leftType = (leftVariableElement == null)
+          ? lhs.typeOrThrow
+          : leftVariableElement.type;
+    }
+
+    if (!leftType.isVoid && checkForUseOfVoidResult(rhs)) {
+      return;
+    }
+
+    _checkForAssignableExpression(
+        rhs, leftType, CompileTimeErrorCode.INVALID_ASSIGNMENT);
   }
 
   /// Check for situations where the result of a method or function is used,
@@ -148,6 +156,18 @@ mixin ErrorDetectionHelpers {
       SyntacticEntity errorEntity,
       Map<DartType, NonPromotionReason>? whyNotPromoted);
 
+  /// Return the variable element represented by the given [expression], or
+  /// `null` if there is no such element.
+  VariableElement? getVariableElement(Expression? expression) {
+    if (expression is Identifier) {
+      var element = expression.staticElement;
+      if (element is VariableElement) {
+        return element;
+      }
+    }
+    return null;
+  }
+
   /// Verify that the given [expression] can be assigned to its corresponding
   /// parameters.
   ///
@@ -167,4 +187,40 @@ mixin ErrorDetectionHelpers {
         expression, expectedStaticType, expression.typeOrThrow, errorCode,
         whyNotPromotedInfo: whyNotPromotedInfo);
   }
+
+  bool _checkForAssignableExpression(
+      Expression expression, DartType expectedStaticType, ErrorCode errorCode) {
+    DartType actualStaticType = expression.typeOrThrow;
+    return _checkForAssignableExpressionAtType(
+        expression, actualStaticType, expectedStaticType, errorCode);
+  }
+
+  bool _checkForAssignableExpressionAtType(
+      Expression expression,
+      DartType actualStaticType,
+      DartType expectedStaticType,
+      ErrorCode errorCode,
+      {Map<DartType, NonPromotionReason> Function()? whyNotPromotedInfo}) {
+    if (!typeSystem.isAssignableTo(actualStaticType, expectedStaticType)) {
+      AstNode getErrorNode(AstNode node) {
+        if (node is CascadeExpression) {
+          return getErrorNode(node.target);
+        }
+        if (node is ParenthesizedExpression) {
+          return getErrorNode(node.expression);
+        }
+        return node;
+      }
+
+      errorReporter.reportErrorForNode(
+        errorCode,
+        getErrorNode(expression),
+        [actualStaticType, expectedStaticType],
+        computeWhyNotPromotedMessages(
+            expression, expression, whyNotPromotedInfo?.call()),
+      );
+      return false;
+    }
+    return true;
+  }
 }

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

@@ -350,7 +350,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
         operatorType == TokenType.QUESTION_QUESTION_EQ) {
       // Already handled in the assignment resolver.
       if (lhs is! SimpleIdentifier) {
-        _checkForInvalidAssignment(lhs, rhs);
+        checkForInvalidAssignment(lhs, rhs);
       }
     } else {
       checkForArgumentTypeNotAssignableForArgument(rhs);
@@ -572,7 +572,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
 
   @override
   void visitDefaultFormalParameter(DefaultFormalParameter node) {
-    _checkForInvalidAssignment(node.identifier, node.defaultValue);
+    checkForInvalidAssignment(node.identifier, node.defaultValue);
     super.visitDefaultFormalParameter(node);
   }
 
@@ -1249,7 +1249,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     SimpleIdentifier nameNode = node.name;
     var initializerNode = node.initializer;
     // do checks
-    _checkForInvalidAssignment(nameNode, initializerNode);
     _checkForImplicitDynamicIdentifier(node, nameNode);
     _checkForAbstractOrExternalVariableInitializer(node);
     // visit name
@@ -1525,13 +1524,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     }
   }
 
-  bool _checkForAssignableExpression(
-      Expression expression, DartType expectedStaticType, ErrorCode errorCode) {
-    DartType actualStaticType = expression.typeOrThrow;
-    return checkForAssignableExpressionAtType(
-        expression, actualStaticType, expectedStaticType, errorCode);
-  }
-
   /// Verify that the given [expression] is not final.
   ///
   /// See [StaticWarningCode.ASSIGNMENT_TO_CONST],
@@ -2753,43 +2745,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     }
   }
 
-  /// Verify that the given left hand side ([lhs]) and right hand side ([rhs])
-  /// represent a valid assignment.
-  ///
-  /// See [CompileTimeErrorCode.INVALID_ASSIGNMENT].
-  void _checkForInvalidAssignment(Expression? lhs, Expression? rhs) {
-    if (lhs == null || rhs == null) {
-      return;
-    }
-
-    if (lhs is IndexExpression &&
-            identical(lhs.realTarget.staticType, NeverTypeImpl.instance) ||
-        lhs is PrefixedIdentifier &&
-            identical(lhs.prefix.staticType, NeverTypeImpl.instance) ||
-        lhs is PropertyAccess &&
-            identical(lhs.realTarget.staticType, NeverTypeImpl.instance)) {
-      return;
-    }
-
-    DartType leftType;
-    var parent = lhs.parent;
-    if (parent is AssignmentExpression && parent.leftHandSide == lhs) {
-      leftType = parent.writeType!;
-    } else {
-      var leftVariableElement = getVariableElement(lhs);
-      leftType = (leftVariableElement == null)
-          ? lhs.typeOrThrow
-          : leftVariableElement.type;
-    }
-
-    if (!leftType.isVoid && checkForUseOfVoidResult(rhs)) {
-      return;
-    }
-
-    _checkForAssignableExpression(
-        rhs, leftType, CompileTimeErrorCode.INVALID_ASSIGNMENT);
-  }
-
   /// Check the given [initializer] to ensure that the field being initialized
   /// is a valid field. The [fieldName] is the field name from the
   /// [ConstructorFieldInitializer]. The [staticElement] is the static element
@@ -5167,18 +5122,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
 
     return fields.toList();
   }
-
-  /// Return the variable element represented by the given [expression], or
-  /// `null` if there is no such element.
-  static VariableElement? getVariableElement(Expression? expression) {
-    if (expression is Identifier) {
-      var element = expression.staticElement;
-      if (element is VariableElement) {
-        return element;
-      }
-    }
-    return null;
-  }
 }
 
 /// A record of the elements that will be declared in some scope (block), but

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

@@ -2155,6 +2155,7 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
             isFinal: parent.isFinal, isLate: parent.isLate);
       }
     }
+    checkForInvalidAssignment(node.name, node.initializer);
   }
 
   @override