[cfe] Remove old method invocation encoding nodes

TEST=existing

Change-Id: I05ee649ecfa7945e2e0f5e5d09441d8916a9c46e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/208185
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Dmitry Stefantsov <[email protected]>

Author: johnniwinther

pkg/compiler/lib/src/inferrer/builder_kernel.dart

@@ -1049,32 +1049,6 @@ class KernelTypeGraphBuilder extends ir.Visitor<TypeInformation>
         node, node.receiver, receiverType, selector, arguments, null);
   }
 
-  @override
-  TypeInformation visitMethodInvocation(ir.MethodInvocation node) {
-    Selector selector = _elementMap.getSelector(node);
-    ir.Expression receiver = node.receiver;
-    if (receiver is ir.VariableGet &&
-        receiver.variable.parent is ir.FunctionDeclaration) {
-      // TODO(johnniwinther). This triggers the computation of the mask for the
-      // receiver of the call to `call`. Remove this when the ssa builder
-      // recognizes local function invocation directly.
-      _typeOfReceiver(node, node.receiver);
-      // This is an invocation of a named local function.
-      return _handleLocalFunctionInvocation(
-          node, receiver.variable.parent, node.arguments, selector);
-    }
-
-    TypeInformation receiverType = visit(receiver);
-    ArgumentsTypes arguments = analyzeArguments(node.arguments);
-    if (selector.name == '==') {
-      return _handleEqualsCall(node, node.receiver, receiverType,
-          node.arguments.positional.first, arguments.positional[0]);
-    }
-
-    return _handleMethodInvocation(node, node.receiver, receiverType, selector,
-        arguments, node.interfaceTarget);
-  }
-
   ir.VariableDeclaration _getVariableDeclaration(ir.Expression node) {
     return node is ir.VariableGet ? node.variable : null;
   }
@@ -1671,12 +1645,6 @@ class KernelTypeGraphBuilder extends ir.Visitor<TypeInformation>
     return _handlePropertyGet(node, node.receiver);
   }
 
-  @override
-  TypeInformation visitPropertyGet(ir.PropertyGet node) {
-    return _handlePropertyGet(node, node.receiver,
-        interfaceTarget: node.interfaceTarget);
-  }
-
   TypeInformation _handlePropertySet(
       ir.Expression node, ir.Expression receiver, ir.Expression value,
       {ir.Member interfaceTarget}) {
@@ -1715,12 +1683,6 @@ class KernelTypeGraphBuilder extends ir.Visitor<TypeInformation>
     return rhsType;
   }
 
-  @override
-  TypeInformation visitPropertySet(ir.PropertySet node) {
-    return _handlePropertySet(node, node.receiver, node.value,
-        interfaceTarget: node.interfaceTarget);
-  }
-
   @override
   TypeInformation visitInstanceSet(ir.InstanceSet node) {
     return _handlePropertySet(node, node.receiver, node.value,

pkg/compiler/lib/src/inferrer/inferrer_engine.dart

@@ -650,20 +650,17 @@ class InferrerEngine {
     // TODO(johnniwinther): Implement the ad-hoc check in ast inferrer? This
     // mimicks that ast inferrer which return `true` for [ast.Send] and
     // non-const [ast.NewExpression].
-    if (initializer is ir.MethodInvocation ||
-        initializer is ir.InstanceInvocation ||
+    if (initializer is ir.InstanceInvocation ||
         initializer is ir.InstanceGetterInvocation ||
         initializer is ir.DynamicInvocation ||
         initializer is ir.FunctionInvocation ||
         initializer is ir.LocalFunctionInvocation ||
         initializer is ir.EqualsNull ||
         initializer is ir.EqualsCall ||
-        initializer is ir.PropertyGet ||
         initializer is ir.InstanceGet ||
         initializer is ir.DynamicGet ||
         initializer is ir.InstanceTearOff ||
         initializer is ir.FunctionTearOff ||
-        initializer is ir.PropertySet ||
         initializer is ir.InstanceSet ||
         initializer is ir.DynamicSet ||
         initializer is ir.StaticInvocation ||

pkg/compiler/lib/src/ir/cached_static_type.dart

@@ -45,17 +45,10 @@ class CachedStaticType extends StaticTypeBase implements StaticTypeProvider {
   @override
   ir.DartType visitVariableGet(ir.VariableGet node) => _getStaticType(node);
 
-  @override
-  ir.DartType visitPropertyGet(ir.PropertyGet node) => _getStaticType(node);
-
   @override
   ir.DartType visitSuperPropertyGet(ir.SuperPropertyGet node) =>
       _getStaticType(node);
 
-  @override
-  ir.DartType visitMethodInvocation(ir.MethodInvocation node) =>
-      _getStaticType(node);
-
   @override
   ir.DartType visitStaticInvocation(ir.StaticInvocation node) =>
       _getStaticType(node);

pkg/compiler/lib/src/ir/runtime_type_analysis.dart

@@ -90,16 +90,14 @@ RuntimeTypeUseData computeRuntimeTypeUse(
 
   /// Returns `true` if [node] is of the form `e.runtimeType`.
   bool isGetRuntimeType(ir.TreeNode node) {
-    return node is ir.PropertyGet &&
+    return node is ir.InstanceGet &&
             node.name.text == Identifiers.runtimeType_ ||
-        node is ir.InstanceGet && node.name.text == Identifiers.runtimeType_ ||
         node is ir.DynamicGet && node.name.text == Identifiers.runtimeType_;
   }
 
   /// Returns `true` if [node] is of the form `e.toString()`.
   bool isInvokeToString(ir.TreeNode node) {
-    return node is ir.MethodInvocation && node.name.text == 'toString' ||
-        node is ir.InstanceInvocation && node.name.text == 'toString';
+    return node is ir.InstanceInvocation && node.name.text == 'toString';
   }
 
   assert(isGetRuntimeType(node));
@@ -427,17 +425,13 @@ RuntimeTypeUseData computeRuntimeTypeUse(
 
 /// Returns `true` if [node] is a potential invocation of an Object method.
 bool _isObjectMethodInvocation(ir.TreeNode node) {
-  return node is ir.MethodInvocation ||
-      node is ir.InstanceInvocation ||
-      node is ir.EqualsCall;
+  return node is ir.InstanceInvocation || node is ir.EqualsCall;
 }
 
 /// Returns the [_RuntimeTypeAccess] corresponding to [node] if it is an access
 /// of `.runtimeType`, and `null` otherwise.
 _RuntimeTypeAccess _getRuntimeTypeAccess(ir.TreeNode node) {
-  if (node is ir.PropertyGet && node.name.text == 'runtimeType') {
-    return _RuntimeTypeAccess(node, node.receiver);
-  } else if (node is ir.InstanceGet && node.name.text == 'runtimeType') {
+  if (node is ir.InstanceGet && node.name.text == 'runtimeType') {
     return _RuntimeTypeAccess(node, node.receiver);
   } else if (node is ir.DynamicGet && node.name.text == 'runtimeType') {
     return _RuntimeTypeAccess(node, node.receiver);
@@ -455,10 +449,7 @@ class _RuntimeTypeAccess {
 /// Returns the [_EqualsInvocation] corresponding to [node] if it is a call to
 /// of `==`, and `null` otherwise.
 _EqualsInvocation _getEqualsInvocation(ir.TreeNode node) {
-  if (node is ir.MethodInvocation && node.name.text == '==') {
-    return _EqualsInvocation(
-        node, node.receiver, node.arguments.positional.single);
-  } else if (node is ir.EqualsCall) {
+  if (node is ir.EqualsCall) {
     return _EqualsInvocation(node, node.left, node.right);
   }
   return null;

pkg/compiler/lib/src/ir/scope_visitor.dart

@@ -1025,35 +1025,6 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     return complexity;
   }
 
-  @override
-  EvaluationComplexity visitMethodInvocation(ir.MethodInvocation node) {
-    node.receiver = _handleExpression(node.receiver);
-    EvaluationComplexity receiverComplexity = _lastExpressionComplexity;
-    ir.TreeNode receiver = node.receiver;
-    if (node.arguments.types.isNotEmpty) {
-      VariableUse usage;
-      if (receiver is ir.VariableGet &&
-          (receiver.variable.parent is ir.LocalFunction)) {
-        usage =
-            new VariableUse.localTypeArgument(receiver.variable.parent, node);
-      } else {
-        usage = new VariableUse.instanceTypeArgument(node);
-      }
-      visitNodesInContext(node.arguments.types, usage);
-    }
-    EvaluationComplexity complexity = visitArguments(node.arguments);
-    ir.Member interfaceTarget = node.interfaceTarget;
-    if (receiverComplexity.combine(complexity).isConstant &&
-        interfaceTarget is ir.Procedure &&
-        interfaceTarget.kind == ir.ProcedureKind.Operator) {
-      // Only operator invocations can be part of constant expressions so we
-      // only try to compute an implicit constant when the receiver and all
-      // arguments are constant - and are used in an operator call.
-      return _evaluateImplicitConstant(node);
-    }
-    return const EvaluationComplexity.lazy();
-  }
-
   @override
   EvaluationComplexity visitInstanceInvocation(ir.InstanceInvocation node) {
     node.receiver = _handleExpression(node.receiver);
@@ -1168,16 +1139,6 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     return const EvaluationComplexity.lazy();
   }
 
-  @override
-  EvaluationComplexity visitPropertyGet(ir.PropertyGet node) {
-    node.receiver = _handleExpression(node.receiver);
-    EvaluationComplexity complexity = _lastExpressionComplexity;
-    if (complexity.isConstant && node.name.text == 'length') {
-      return _evaluateImplicitConstant(node);
-    }
-    return const EvaluationComplexity.lazy();
-  }
-
   @override
   EvaluationComplexity visitInstanceGet(ir.InstanceGet node) {
     node.receiver = _handleExpression(node.receiver);
@@ -1210,13 +1171,6 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     return const EvaluationComplexity.lazy();
   }
 
-  @override
-  EvaluationComplexity visitPropertySet(ir.PropertySet node) {
-    node.receiver = _handleExpression(node.receiver);
-    node.value = _handleExpression(node.value);
-    return const EvaluationComplexity.lazy();
-  }
-
   @override
   EvaluationComplexity visitInstanceSet(ir.InstanceSet node) {
     node.receiver = _handleExpression(node.receiver);

pkg/compiler/lib/src/ir/static_type.dart

@@ -14,7 +14,6 @@ import 'runtime_type_analysis.dart';
 import 'scope.dart';
 import 'static_type_base.dart';
 import 'static_type_cache.dart';
-import 'util.dart';
 
 /// Enum values for how the target of a static type should be interpreted.
 enum ClassRelation {
@@ -268,28 +267,6 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
         .substituteType(interfaceTarget.getterType);
   }
 
-  /// Computes the result type of the property access [node] on a receiver of
-  /// type [receiverType].
-  ///
-  /// If the `node.interfaceTarget` is `null` but matches an `Object` member
-  /// it is updated to target this member.
-  ir.DartType _computePropertyGetType(
-      ir.PropertyGet node, ir.DartType receiverType) {
-    node.interfaceTarget ??= _resolveDynamicTarget(receiverType, node.name);
-    ir.Member interfaceTarget = node.interfaceTarget;
-    if (interfaceTarget != null) {
-      return _computeInstanceGetType(receiverType, interfaceTarget);
-    }
-    // Treat the properties of Object specially.
-    String nameString = node.name.text;
-    if (nameString == 'hashCode') {
-      return typeEnvironment.coreTypes.intNonNullableRawType;
-    } else if (nameString == 'runtimeType') {
-      return typeEnvironment.coreTypes.typeNonNullableRawType;
-    }
-    return const ir.DynamicType();
-  }
-
   /// Replaces [original] with [replacement] in the AST and removes cached
   /// expression type information for [original].
   void _replaceExpression(ir.Expression original, ir.Expression replacement) {
@@ -308,23 +285,6 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
   void handleRuntimeTypeUse(ir.Expression node, RuntimeTypeUseKind kind,
       ir.DartType receiverType, ir.DartType argumentType) {}
 
-  @override
-  ir.DartType visitPropertyGet(ir.PropertyGet node) {
-    ir.DartType receiverType = visitNode(node.receiver);
-    ir.DartType resultType = _staticTypeCache._expressionTypes[node] =
-        _computePropertyGetType(node, receiverType);
-    receiverType = _narrowInstanceReceiver(node.interfaceTarget, receiverType);
-    if (node.interfaceTarget != null) {
-      handleInstanceGet(node, receiverType, node.interfaceTarget, resultType);
-    } else {
-      handleDynamicGet(node, receiverType, node.name, resultType);
-    }
-    if (node.name.text == Identifiers.runtimeType_) {
-      handleRuntimeTypeGet(receiverType, node);
-    }
-    return resultType;
-  }
-
   void handleRuntimeTypeGet(ir.DartType receiverType, ir.Expression node) {
     RuntimeTypeUseData data =
         computeRuntimeTypeUse(_pendingRuntimeTypeUseData, node);
@@ -460,37 +420,6 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
     return null;
   }
 
-  @override
-  ir.DartType visitPropertySet(ir.PropertySet node) {
-    ir.DartType receiverType = visitNode(node.receiver);
-    ir.DartType valueType = super.visitPropertySet(node);
-    ir.Member interfaceTarget = node.interfaceTarget;
-    if (interfaceTarget == null) {
-      interfaceTarget = _resolveDynamicSet(receiverType, node.name);
-      if (interfaceTarget != null) {
-        ir.DartType setterType =
-            _computeInstanceSetType(receiverType, interfaceTarget);
-        ir.AsExpression implicitCast =
-            _createImplicitAsIfNeeded(node.value, valueType, setterType);
-        if (implicitCast != null) {
-          node.value = implicitCast..parent = node;
-          // Visit the newly created as expression; the original value has
-          // already been visited.
-          handleAsExpression(implicitCast, valueType);
-          valueType = setterType;
-        }
-        node.interfaceTarget = interfaceTarget;
-      }
-    }
-    receiverType = _narrowInstanceReceiver(interfaceTarget, receiverType);
-    if (interfaceTarget != null) {
-      handleInstanceSet(node, receiverType, node.interfaceTarget, valueType);
-    } else {
-      handleDynamicSet(node, receiverType, node.name, valueType);
-    }
-    return valueType;
-  }
-
   @override
   ir.DartType visitDynamicSet(ir.DynamicSet node) {
     ir.DartType receiverType = visitNode(node.receiver);
@@ -910,69 +839,6 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
     }
   }
 
-  @override
-  ir.DartType visitMethodInvocation(ir.MethodInvocation node) {
-    ArgumentTypes argumentTypes = _visitArguments(node.arguments);
-    ir.DartType receiverType = visitNode(node.receiver);
-    ir.Member interfaceTarget = node.interfaceTarget ??
-        _resolveDynamicInvocationTarget(
-            receiverType, node.name, node.arguments);
-    ir.DartType returnType;
-    if (interfaceTarget != null) {
-      ir.DartType functionType = _computeInstanceInvocationType(
-          receiverType, interfaceTarget, node.arguments, argumentTypes);
-      if (node.interfaceTarget == null) {
-        // We change [node] from being a dynamic invocation to an instance
-        // invocation, so we need to add static type checks to the arguments to
-        // match instance invocations created by the CFE.
-        // TODO(johnniwinther): Handle incremental target improvement.
-        _updateMethodInvocationTarget(node, argumentTypes, functionType);
-        node.interfaceTarget = interfaceTarget;
-      }
-      returnType = _getFunctionReturnType(functionType);
-    } else {
-      returnType = _computeDynamicInvocationReturnType(node, receiverType);
-    }
-    receiverType = _narrowInstanceReceiver(node.interfaceTarget, receiverType);
-    if (node.name.text == '==') {
-      TypeMap afterInvocation = typeMap;
-      ir.Expression left = node.receiver;
-      ir.Expression right = node.arguments.positional[0];
-      if (isNullLiteral(right)) {
-        _registerEqualsNull(afterInvocation, left);
-      }
-      if (isNullLiteral(left)) {
-        _registerEqualsNull(afterInvocation, right);
-      }
-      assert(node.interfaceTarget != null);
-      handleEqualsCall(left, receiverType, right, argumentTypes.positional[0],
-          node.interfaceTarget);
-    } else if (node.interfaceTarget != null) {
-      handleInstanceInvocation(
-          node, receiverType, interfaceTarget, argumentTypes);
-    } else {
-      ir.Expression receiver = node.receiver;
-      if (receiver is ir.VariableGet &&
-          receiver.variable.isFinal &&
-          receiver.variable.parent is ir.FunctionDeclaration) {
-        handleLocalFunctionInvocation(
-            node, receiver.variable.parent, argumentTypes, returnType);
-      } else {
-        handleDynamicInvocation(node, receiverType, argumentTypes, returnType);
-        // TODO(johnniwinther): Avoid treating a known function call as a
-        // dynamic call when CFE provides a way to distinguish the two.
-        if (operatorFromString(node.name.text) == null &&
-            receiverType is ir.DynamicType) {
-          // We might implicitly call a getter that returns a function.
-          handleFunctionInvocation(
-              node, const ir.DynamicType(), argumentTypes, returnType);
-        }
-      }
-    }
-    _staticTypeCache._expressionTypes[node] = returnType;
-    return returnType;
-  }
-
   @override
   ir.DartType visitInstanceInvocation(ir.InstanceInvocation node) {
     ArgumentTypes argumentTypes = _visitArguments(node.arguments);
@@ -1060,9 +926,6 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
       receiverType = _narrowInstanceReceiver(interfaceTarget, receiverType);
       handleInstanceInvocation(
           replacement, receiverType, interfaceTarget, argumentTypes);
-      if (replacement is ir.MethodInvocation) {
-        _staticTypeCache._expressionTypes[replacement] = resultType;
-      }
       return resultType;
     } else if (node.name == ir.Name.callName &&
         (receiverType is ir.FunctionType ||