Elements. Migrate BinaryExpressionResolver.

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

Author: scheglov

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -1842,9 +1842,17 @@ final class BinaryExpressionImpl extends ExpressionImpl
   @override
   MethodElement2? get element => staticElement?.asElement2;
 
+  set element(MethodElement2? value) {
+    staticElement = value?.asElement;
+  }
+
   @override
   Token get endToken => _rightOperand.endToken;
 
+  set fragment(MethodFragment? value) {
+    staticElement = value as MethodElement;
+  }
+
   @override
   ExpressionImpl get leftOperand => _leftOperand;
 

pkg/analyzer/lib/src/dart/element/type_system.dart

@@ -1688,23 +1688,10 @@ class TypeSystemImpl implements TypeSystem {
       TokenType operator,
       DartType rightType,
       DartType currentType,
-      MethodElement? operatorElement) {
+      MethodElement2? operatorElement) {
     if (operatorElement == null) return currentType;
     return _refineNumericInvocationTypeNullSafe(
-        leftType, operatorElement, [rightType], currentType);
-  }
-
-  /// Determine the type of a binary expression with the given [operator] whose
-  /// left operand has the type [leftType] and whose right operand has the type
-  /// [rightType], given that resolution has so far produced the [currentType].
-  DartType refineBinaryExpressionType2(
-      DartType leftType,
-      TokenType operator,
-      DartType rightType,
-      DartType currentType,
-      MethodElement2? operatorElement) {
-    return refineBinaryExpressionType(
-        leftType, operator, rightType, currentType, operatorElement?.asElement);
+        leftType, operatorElement.asElement, [rightType], currentType);
   }
 
   /// Determines the context type for the parameters of a method invocation

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

@@ -284,7 +284,7 @@ class AssignmentExpressionResolver {
         assignedType = DynamicTypeImpl.instance;
       } else if (operatorElement != null) {
         var rightType = rightHandSide.typeOrThrow;
-        assignedType = _typeSystem.refineBinaryExpressionType2(
+        assignedType = _typeSystem.refineBinaryExpressionType(
           leftType,
           operator,
           rightType,

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

@@ -2,14 +2,12 @@
 // 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.
 
-// ignore_for_file: analyzer_use_new_elements
-
 import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:_fe_analyzer_shared/src/types/shared_type.dart';
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
 import 'package:analyzer/dart/ast/token.dart';
-import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
@@ -24,7 +22,6 @@ import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/super_context.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 
 /// Helper for resolving [BinaryExpression]s.
 class BinaryExpressionResolver {
@@ -289,13 +286,13 @@ class BinaryExpressionResolver {
 
     var invokeType = node.staticInvokeType;
     TypeImpl rightContextType;
-    if (invokeType != null && invokeType.parameters.isNotEmpty) {
+    if (invokeType != null && invokeType.formalParameters.isNotEmpty) {
       // If this is a user-defined operator, set the right operand context
       // using the operator method's parameter type.
-      var rightParam = invokeType.parameters[0];
-      rightContextType = _typeSystem.refineNumericInvocationContext(
+      var rightParam = invokeType.formalParameters[0];
+      rightContextType = _typeSystem.refineNumericInvocationContext2(
           left.staticType,
-          node.staticElement,
+          node.element,
           contextType,
           // TODO(paulberry): eliminate this cast by changing the type of
           // `FunctionTypeImpl.parameters` to `List<ParameterElementMixin>`.
@@ -373,13 +370,13 @@ class BinaryExpressionResolver {
     left.setPseudoExpressionStaticType(InvalidTypeImpl.instance);
 
     switch (augmentationTarget) {
-      case MethodElement operatorElement:
-        left.element = operatorElement;
+      case MethodFragment fragment:
+        left.fragment = fragment;
         left.setPseudoExpressionStaticType(
             _resolver.thisType ?? InvalidTypeImpl.instance);
-        if (operatorElement.name == methodName) {
-          node.staticElement = operatorElement;
-          node.staticInvokeType = operatorElement.type;
+        if (fragment.name2 == methodName) {
+          node.fragment = fragment;
+          node.staticInvokeType = fragment.element.type;
         } else {
           _errorReporter.atToken(
             left.augmentedKeyword,
@@ -389,20 +386,21 @@ class BinaryExpressionResolver {
             ],
           );
         }
-      case PropertyAccessorElement accessor:
-        left.element = accessor;
-        if (accessor.isGetter) {
-          left.setPseudoExpressionStaticType(accessor.returnType);
+      case PropertyAccessorFragment fragment:
+        left.fragment = fragment;
+        var element = fragment.element;
+        if (element is GetterElement) {
+          left.setPseudoExpressionStaticType(element.returnType);
           _resolveUserDefinableElement(node, methodName);
         } else {
           _errorReporter.atToken(
             left.augmentedKeyword,
             CompileTimeErrorCode.AUGMENTED_EXPRESSION_IS_SETTER,
           );
         }
-      case PropertyInducingElement property:
-        left.element = property;
-        left.setPseudoExpressionStaticType(property.type);
+      case PropertyInducingFragment fragment:
+        left.fragment = fragment;
+        left.setPseudoExpressionStaticType(fragment.element.type);
         _resolveUserDefinableElement(node, methodName);
     }
 
@@ -417,18 +415,18 @@ class BinaryExpressionResolver {
     ExpressionImpl leftOperand = node.leftOperand;
 
     if (leftOperand is ExtensionOverrideImpl) {
-      var extension = leftOperand.element;
-      var member = extension.getMethod(methodName);
+      var extension = leftOperand.element2;
+      var member = extension.getMethod2(methodName);
       if (member == null) {
         // Extension overrides can only be used with named extensions so it is
         // safe to assume `extension.name` is non-`null`.
         _errorReporter.atToken(
           node.operator,
           CompileTimeErrorCode.UNDEFINED_EXTENSION_OPERATOR,
-          arguments: [methodName, extension.name!],
+          arguments: [methodName, extension.name3!],
         );
       }
-      node.staticElement = member;
+      node.element = member;
       node.staticInvokeType = member?.type;
       return;
     }
@@ -455,7 +453,7 @@ class BinaryExpressionResolver {
       nameErrorEntity: node,
     );
 
-    node.staticElement = result.getter2?.asElement as MethodElement?;
+    node.element = result.getter2 as MethodElement2?;
     node.staticInvokeType = result.getter2?.type;
     if (result.needsGetterError) {
       if (leftOperand is SuperExpression) {
@@ -506,7 +504,7 @@ class BinaryExpressionResolver {
         node.operator.type,
         node.rightOperand.typeOrThrow,
         staticType,
-        node.staticElement,
+        node.element,
       );
     }
     node.recordStaticType(staticType, resolver: _resolver);