[analyzer] Use ExpressionImpl when interfacing with shared code

Change the analyzer's use of the following generic types so that it
supplies the type parameter `ExpressionImpl` instead of `Expression`
as the type of AST node it uses to represent expressions:

- `CaseHeadOrDefaultInfo`
- `FlowAnalysis`
- `MapPatternEntry`
- `MatchContext`
- `NullShortingMixin`
- `PropertyTarget`
- `SwitchExpressionMemberInfo`
- `SwitchStatementMemberInfo`
- `TypeAnalyzer`
- `TypeAnalyzerErrors`

This required adjusting some type casts and `is` tests to test against
concrete expression types instead of abstract public interface types
(e.g. `as SimpleIdentifierImpl` instead of `as SimpleIdentifier`).

In some places I was able to avoid adding casts by changing method
parameters to accept concrete statement types instead of abstract
public interface types. This required adding the `covariant` keyword
to some methods.

This is part of a larger arc of work to change the analyzer's use of
the shared code so that the type parameters it supplies are not part
of the analyzer public API. See
#59763.

Change-Id: Ib33f0f5b3b30bfe2554316b5aa7c11524b63bcd3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/403161
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

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

@@ -85,7 +85,7 @@ class AssignmentExpressionResolver {
       var leftType = node.writeType;
       if (writeElement is VariableElement) {
         leftType = _resolver.localVariableTypeProvider
-            .getType(left as SimpleIdentifier, isRead: false);
+            .getType(left as SimpleIdentifierImpl, isRead: false);
       }
       rhsContext = _computeRhsContext(node, leftType!, operator, right);
     }

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

@@ -406,9 +406,9 @@ class BinaryExpressionResolver {
     String methodName, {
     bool promoteLeftTypeToNonNull = false,
   }) {
-    Expression leftOperand = node.leftOperand;
+    ExpressionImpl leftOperand = node.leftOperand;
 
-    if (leftOperand is ExtensionOverride) {
+    if (leftOperand is ExtensionOverrideImpl) {
       var extension = leftOperand.element;
       var member = extension.getMethod(methodName);
       if (member == null) {

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

@@ -96,7 +96,7 @@ class FlowAnalysisHelper {
   final bool inferenceUpdate4Enabled;
 
   /// The current flow, when resolving a function body, or `null` otherwise.
-  FlowAnalysis<AstNode, StatementImpl, Expression, PromotableElementImpl2,
+  FlowAnalysis<AstNode, StatementImpl, ExpressionImpl, PromotableElementImpl2,
       SharedTypeView<DartType>>? flow;
 
   FlowAnalysisHelper(bool retainDataForTesting, FeatureSet featureSet,
@@ -126,7 +126,7 @@ class FlowAnalysisHelper {
     return _LocalVariableTypeProvider(this);
   }
 
-  void asExpression(AsExpression node) {
+  void asExpression(AsExpressionImpl node) {
     if (flow == null) return;
 
     var expression = node.expression;
@@ -136,7 +136,7 @@ class FlowAnalysisHelper {
         expression, SharedTypeView(typeAnnotation.typeOrThrow));
   }
 
-  void assignmentExpression(AssignmentExpression node) {
+  void assignmentExpression(AssignmentExpressionImpl node) {
     if (flow == null) return;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
@@ -177,7 +177,7 @@ class FlowAnalysisHelper {
           as AssignedVariablesForTesting<AstNode, PromotableElementImpl2>;
     }
     flow = isNonNullableByDefault
-        ? FlowAnalysis<AstNode, StatementImpl, Expression,
+        ? FlowAnalysis<AstNode, StatementImpl, ExpressionImpl,
             PromotableElementImpl2, SharedTypeView<DartType>>(
             typeOperations,
             assignedVariables!,
@@ -186,7 +186,7 @@ class FlowAnalysisHelper {
             fieldPromotionEnabled: fieldPromotionEnabled,
             inferenceUpdate4Enabled: inferenceUpdate4Enabled,
           )
-        : FlowAnalysis<AstNode, StatementImpl, Expression,
+        : FlowAnalysis<AstNode, StatementImpl, ExpressionImpl,
                 PromotableElementImpl2, SharedTypeView<DartType>>.legacy(
             typeOperations, assignedVariables!);
   }
@@ -257,7 +257,7 @@ class FlowAnalysisHelper {
     }
   }
 
-  void for_bodyBegin(AstNode node, Expression? condition) {
+  void for_bodyBegin(AstNode node, ExpressionImpl? condition) {
     flow?.for_bodyBegin(node is StatementImpl ? node : null, condition);
   }
 
@@ -295,7 +295,7 @@ class FlowAnalysisHelper {
     return isUnassigned;
   }
 
-  void isExpression(IsExpression node) {
+  void isExpression(IsExpressionImpl node) {
     if (flow == null) return;
 
     var expression = node.expression;
@@ -1198,7 +1198,7 @@ class _LocalVariableTypeProvider implements LocalVariableTypeProvider {
   _LocalVariableTypeProvider(this._manager);
 
   @override
-  DartType getType(SimpleIdentifier node, {required bool isRead}) {
+  DartType getType(SimpleIdentifierImpl node, {required bool isRead}) {
     var variable = node.element as VariableElement2;
     if (variable is PromotableElementImpl2) {
       var promotedType = isRead

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

@@ -120,15 +120,15 @@ class ForResolver {
     return iteratedType.typeArguments.single;
   }
 
-  void _forEachParts(AstNode node, bool isAsync, ForEachParts forEachParts,
+  void _forEachParts(AstNode node, bool isAsync, ForEachPartsImpl forEachParts,
       void Function() visitBody) {
-    Expression iterable = forEachParts.iterable;
+    ExpressionImpl iterable = forEachParts.iterable;
     DeclaredIdentifierImpl? loopVariable;
-    SimpleIdentifier? identifier;
+    SimpleIdentifierImpl? identifier;
     Element2? identifierElement;
     if (forEachParts is ForEachPartsWithDeclarationImpl) {
       loopVariable = forEachParts.loopVariable;
-    } else if (forEachParts is ForEachPartsWithIdentifier) {
+    } else if (forEachParts is ForEachPartsWithIdentifierImpl) {
       identifier = forEachParts.identifier;
       // TODO(scheglov): replace with lexical lookup
       inferenceLogWriter?.setExpressionVisitCodePath(
@@ -199,16 +199,17 @@ class ForResolver {
     _resolver.flowAnalysis.flow?.forEach_end();
   }
 
-  void _forParts(AstNode node, ForParts forParts, void Function() visitBody) {
-    if (forParts is ForPartsWithDeclarations) {
+  void _forParts(
+      AstNode node, ForPartsImpl forParts, void Function() visitBody) {
+    if (forParts is ForPartsWithDeclarationsImpl) {
       forParts.variables.accept(_resolver);
-    } else if (forParts is ForPartsWithExpression) {
+    } else if (forParts is ForPartsWithExpressionImpl) {
       if (forParts.initialization case var initialization?) {
         _resolver.analyzeExpression(
             initialization, _resolver.operations.unknownType);
         _resolver.popRewrite();
       }
-    } else if (forParts is ForPartsWithPattern) {
+    } else if (forParts is ForPartsWithPatternImpl) {
       forParts.variables.accept(_resolver);
     } else {
       throw StateError('Unrecognized for loop parts');

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

@@ -391,7 +391,7 @@ class FunctionReferenceResolver {
   /// function element, tearing off an extension element declared on [Function],
   /// and tearing off an extension element declared on a function type.
   Element? _resolveFunctionTypeFunction(
-    Expression receiver,
+    ExpressionImpl receiver,
     SimpleIdentifier methodName,
     FunctionType receiverType,
   ) {
@@ -869,11 +869,11 @@ class FunctionReferenceResolver {
   /// Returns `null` if [receiver]'s type is `null`, a [TypeParameterType],
   /// or a type alias for a non-interface type.
   DartType? _resolveTypeProperty({
-    required Expression receiver,
+    required ExpressionImpl receiver,
     required SimpleIdentifierImpl name,
     required SyntacticEntity nameErrorEntity,
   }) {
-    if (receiver is Identifier) {
+    if (receiver is IdentifierImpl) {
       var receiverElement = receiver.staticElement;
       if (receiverElement is InterfaceElement) {
         var element = _resolveStaticElement(receiverElement, name);

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

@@ -483,7 +483,7 @@ class InvocationInferrer<Node extends AstNodeImpl> {
       var leftOperandInfo = identicalArgumentInfo[0]!;
       var rightOperandInfo = identicalArgumentInfo[1]!;
       flow?.equalityOperation_end(
-          argumentList.parent as Expression,
+          argumentList.parent as ExpressionImpl,
           leftOperandInfo.expressionInfo,
           SharedTypeView<DartType>(leftOperandInfo.staticType),
           rightOperandInfo.expressionInfo,

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

@@ -499,7 +499,7 @@ class MethodInvocationResolver with ScopeHelpers {
   /// process, then returns that new node. Otherwise, returns `null`.
   FunctionExpressionInvocationImpl? _resolveReceiverNever(
     MethodInvocationImpl node,
-    Expression receiver,
+    ExpressionImpl receiver,
     DartType receiverType,
     List<WhyNotPromotedGetter> whyNotPromotedArguments, {
     required DartType contextType,
@@ -804,7 +804,7 @@ class MethodInvocationResolver with ScopeHelpers {
   /// process, then returns that new node. Otherwise, returns `null`.
   FunctionExpressionInvocationImpl? _resolveReceiverType({
     required MethodInvocationImpl node,
-    required Expression? receiver,
+    required ExpressionImpl? receiver,
     required DartType receiverType,
     required SimpleIdentifierImpl nameNode,
     required String name,

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

@@ -124,7 +124,7 @@ class PostfixExpressionResolver {
   }
 
   void _resolve1(PostfixExpressionImpl node, DartType receiverType) {
-    Expression operand = node.operand;
+    ExpressionImpl operand = node.operand;
 
     if (identical(receiverType, NeverTypeImpl.instance)) {
       _resolver.errorReporter.atNode(

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

@@ -153,9 +153,9 @@ class PrefixExpressionResolver {
     TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator ||
         operatorType.isIncrementOperator) {
-      Expression operand = node.operand;
+      ExpressionImpl operand = node.operand;
       String methodName = _getPrefixOperator(node);
-      if (operand is ExtensionOverride) {
+      if (operand is ExtensionOverrideImpl) {
         var element = operand.element;
         var member = element.getMethod(methodName);
         if (member == null) {

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

@@ -41,13 +41,13 @@ class PropertyElementResolver with ScopeHelpers {
   TypeSystemImpl get _typeSystem => _resolver.typeSystem;
 
   PropertyElementResolverResult resolveIndexExpression({
-    required IndexExpression node,
+    required IndexExpressionImpl node,
     required bool hasRead,
     required bool hasWrite,
   }) {
     var target = node.realTarget;
 
-    if (target is ExtensionOverride) {
+    if (target is ExtensionOverrideImpl) {
       var result = _extensionResolver.getOverrideMember(target, '[]');
 
       // TODO(scheglov): Change ExtensionResolver to set `needsGetterError`.
@@ -149,7 +149,7 @@ class PropertyElementResolver with ScopeHelpers {
   }
 
   PropertyElementResolverResult resolvePrefixedIdentifier({
-    required PrefixedIdentifier node,
+    required PrefixedIdentifierImpl node,
     required bool hasRead,
     required bool hasWrite,
     bool forAnnotation = false,
@@ -180,14 +180,14 @@ class PropertyElementResolver with ScopeHelpers {
   }
 
   PropertyElementResolverResult resolvePropertyAccess({
-    required PropertyAccess node,
+    required PropertyAccessImpl node,
     required bool hasRead,
     required bool hasWrite,
   }) {
     var target = node.realTarget;
     var propertyName = node.propertyName;
 
-    if (target is ExtensionOverride) {
+    if (target is ExtensionOverrideImpl) {
       return _resolveTargetExtensionOverride(
         target: target,
         propertyName: propertyName,
@@ -196,7 +196,7 @@ class PropertyElementResolver with ScopeHelpers {
       );
     }
 
-    if (target is SuperExpression) {
+    if (target is SuperExpressionImpl) {
       return _resolveTargetSuperExpression(
         node: node,
         target: target,
@@ -388,8 +388,8 @@ class PropertyElementResolver with ScopeHelpers {
   }
 
   PropertyElementResolverResult _resolve({
-    required Expression node,
-    required Expression target,
+    required ExpressionImpl node,
+    required ExpressionImpl target,
     required bool isCascaded,
     required bool isNullAware,
     required SimpleIdentifier propertyName,
@@ -402,7 +402,7 @@ class PropertyElementResolver with ScopeHelpers {
     // hierarchy, instead we just look for the member in the type only.  This
     // does not apply to conditional property accesses (i.e. 'C?.m').
     //
-    if (target is Identifier) {
+    if (target is IdentifierImpl) {
       var targetElement = target.staticElement;
       if (targetElement is InterfaceElement) {
         return _resolveTargetInterfaceElement(
@@ -431,7 +431,7 @@ class PropertyElementResolver with ScopeHelpers {
     // then look for the member in the extension. This does not apply to
     // conditional property accesses (i.e. 'C?.m').
     //
-    if (target is Identifier) {
+    if (target is IdentifierImpl) {
       var targetElement = target.staticElement;
       if (targetElement is ExtensionElement) {
         return _resolveTargetExtensionElement(
@@ -465,7 +465,7 @@ class PropertyElementResolver with ScopeHelpers {
       targetType = _typeSystem.promoteToNonNull(targetType);
     }
 
-    if (target is TypeLiteral && target.type.type is FunctionType) {
+    if (target is TypeLiteralImpl && target.type.type is FunctionType) {
       // There is no possible resolution for a property access of a function
       // type literal (which can only be a type instantiation of a type alias
       // of a function type).
@@ -505,7 +505,7 @@ class PropertyElementResolver with ScopeHelpers {
                   node,
                   isCascaded
                       ? CascadePropertyTarget.singleton
-                          as PropertyTarget<Expression>
+                          as PropertyTarget<ExpressionImpl>
                       : ExpressionPropertyTarget(target),
                   propertyName.name,
                   result.getter,
@@ -796,7 +796,7 @@ class PropertyElementResolver with ScopeHelpers {
   }
 
   PropertyElementResolverResult _resolveTargetSuperExpression({
-    required Expression node,
+    required ExpressionImpl node,
     required SuperExpression target,
     required SimpleIdentifier propertyName,
     required bool hasRead,