Change MethodInvocation.interfaceTarget from a Procedure to a Member.

pkg/kernel/lib/type_checker.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // 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.
 library kernel.type_checker;
 
 import 'ast.dart';
 import 'class_hierarchy.dart';
 import 'core_types.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
@@ skipping 230 matching lines @@
     // have a declared interface target.
     fail(access, '$member is not accessible on a receiver of type $type');
     return Substitution.bottomForClass(superclass); // Continue type checking.
   }
 
   Substitution getSuperReceiverType(Member member) {
     return Substitution.fromSupertype(
         hierarchy.getClassAsInstanceOf(currentClass, member.enclosingClass));
   }
 
-  DartType handleCall(Arguments arguments, FunctionNode function,
+  DartType handleCall(Arguments arguments, DartType functionType,
       {Substitution receiver: Substitution.empty,
       List<TypeParameter> typeParameters}) {
-    typeParameters ??= function.typeParameters;
-    if (arguments.positional.length < function.requiredParameterCount) {
-      fail(arguments, 'Too few positional arguments');
-      return const BottomType();
-    }
-    if (arguments.positional.length > function.positionalParameters.length) {
-      fail(arguments, 'Too many positional arguments');
-      return const BottomType();
-    }
-    if (arguments.types.length != typeParameters.length) {
-      fail(arguments, 'Wrong number of type arguments');
-      return const BottomType();
-    }
-    var instantiation = Substitution.fromPairs(typeParameters, arguments.types);
-    var substitution = Substitution.combine(receiver, instantiation);
-    for (int i = 0; i < typeParameters.length; ++i) {
-      var argument = arguments.types[i];
-      var bound = substitution.substituteType(typeParameters[i].bound);
-      checkAssignable(arguments, argument, bound);
-    }
-    for (int i = 0; i < arguments.positional.length; ++i) {
-      var expectedType = substitution.substituteType(
-          function.positionalParameters[i].type,
-          contravariant: true);
-      arguments.positional[i] =
-          checkAndDowncastExpression(arguments.positional[i], expectedType);
-    }
-    for (int i = 0; i < arguments.named.length; ++i) {
-      var argument = arguments.named[i];
-      bool found = false;
-      for (int j = 0; j < function.namedParameters.length; ++j) {
-        if (argument.name == function.namedParameters[j].name) {
-          var expectedType = substitution.substituteType(
-              function.namedParameters[j].type,
-              contravariant: true);
-          argument.value =
-              checkAndDowncastExpression(argument.value, expectedType);
-          found = true;
-          break;
+    if (functionType is FunctionType) {
+      typeParameters ??= functionType.typeParameters;
+      if (arguments.positional.length < functionType.requiredParameterCount) {
+        fail(arguments, 'Too few positional arguments');
+        return const BottomType();
+      }
+      if (arguments.positional.length >
+          functionType.positionalParameters.length) {
+        fail(arguments, 'Too many positional arguments');
+        return const BottomType();
+      }
+      if (arguments.types.length != typeParameters.length) {
+        fail(arguments, 'Wrong number of type arguments');
+        return const BottomType();
+      }
+      var instantiation =
+          Substitution.fromPairs(typeParameters, arguments.types);
+      var substitution = Substitution.combine(receiver, instantiation);
+      for (int i = 0; i < typeParameters.length; ++i) {
+        var argument = arguments.types[i];
+        var bound = substitution.substituteType(typeParameters[i].bound);
+        checkAssignable(arguments, argument, bound);
+      }
+      for (int i = 0; i < arguments.positional.length; ++i) {
+        var expectedType = substitution.substituteType(
+            functionType.positionalParameters[i],
+            contravariant: true);
+        arguments.positional[i] =
+            checkAndDowncastExpression(arguments.positional[i], expectedType);
+      }
+      for (int i = 0; i < arguments.named.length; ++i) {
+        var argument = arguments.named[i];
+        bool found = false;
+        for (int j = 0; j < functionType.namedParameters.length; ++j) {
+          if (argument.name == functionType.namedParameters[j].name) {
+            var expectedType = substitution.substituteType(
+                functionType.namedParameters[j].type,
+                contravariant: true);
+            argument.value =
+                checkAndDowncastExpression(argument.value, expectedType);
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          fail(argument.value, 'Unexpected named parameter: ${argument.name}');
+          return const BottomType();
         }
       }
-      if (!found) {
-        fail(argument.value, 'Unexpected named parameter: ${argument.name}');
-        return const BottomType();
-      }
+      return substitution.substituteType(functionType.returnType);
+    } else {
+      // Note: attempting to resolve .call() on [functionType] could lead to an
+      // infinite regress, so just assume `dynamic`.
+      return const DynamicType();
     }
-    return substitution.substituteType(function.returnType);
   }
 
   DartType _getInternalReturnType(FunctionNode function) {
     switch (function.asyncMarker) {
       case AsyncMarker.Sync:
         return function.returnType;
 
       case AsyncMarker.Async:
         Class container = coreTypes.futureClass;
         DartType returnType = function.returnType;
@@ skipping 61 matching lines @@
     node.otherwise =
         checkAndDowncastExpression(node.otherwise, node.staticType);
     return node.staticType;
   }
 
   @override
   DartType visitConstructorInvocation(ConstructorInvocation node) {
     Constructor target = node.target;
     Arguments arguments = node.arguments;
     Class class_ = target.enclosingClass;
-    handleCall(arguments, target.function,
+    handleCall(arguments, target.function.functionType,
         typeParameters: class_.typeParameters);
     return new InterfaceType(target.enclosingClass, arguments.types);
   }
 
   @override
   DartType visitDirectMethodInvocation(DirectMethodInvocation node) {
-    return handleCall(node.arguments, node.target.function,
+    return handleCall(node.arguments, node.target.getterType,
         receiver: getReceiverType(node, node.receiver, node.target));
   }
 
   @override
   DartType visitDirectPropertyGet(DirectPropertyGet node) {
     var receiver = getReceiverType(node, node.receiver, node.target);
     return receiver.substituteType(node.target.getterType);
   }
 
   @override
@@ skipping 117 matching lines @@
     if (target == null) {
       var receiver = visitExpression(node.receiver);
       if (node.name.name == '==') {
         visitExpression(node.arguments.positional.single);
         return environment.boolType;
       }
       if (node.name.name == 'call' && receiver is FunctionType) {
         return handleFunctionCall(node, receiver, node.arguments);
       }
       return handleDynamicCall(receiver, node.arguments);
-    } else if (environment.isOverloadedArithmeticOperator(target)) {
+    } else if (target is Procedure &&
+        environment.isOverloadedArithmeticOperator(target)) {
       assert(node.arguments.positional.length == 1);
       var receiver = visitExpression(node.receiver);
       var argument = visitExpression(node.arguments.positional[0]);
       return environment.getTypeOfOverloadedArithmetic(receiver, argument);
     } else {
-      return handleCall(node.arguments, target.function,
+      return handleCall(node.arguments, target.getterType,
           receiver: getReceiverType(node, node.receiver, node.interfaceTarget));
     }
   }
 
   @override
   DartType visitPropertyGet(PropertyGet node) {
     if (node.interfaceTarget == null) {
       visitExpression(node.receiver);
       return const DynamicType();
     } else {
@@ skipping 34 matching lines @@
     return const BottomType();
   }
 
   @override
   DartType visitStaticGet(StaticGet node) {
     return node.target.getterType;
   }
 
   @override
   DartType visitStaticInvocation(StaticInvocation node) {
-    return handleCall(node.arguments, node.target.function);
+    return handleCall(node.arguments, node.target.getterType);
   }
 
   @override
   DartType visitStaticSet(StaticSet node) {
     var value = visitExpression(node.value);
     checkAssignable(node.value, value, node.target.setterType);
     return value;
   }
 
   @override
   DartType visitStringConcatenation(StringConcatenation node) {
     node.expressions.forEach(visitExpression);
     return environment.stringType;
   }
 
   @override
   DartType visitStringLiteral(StringLiteral node) {
     return environment.stringType;
   }
 
   @override
   DartType visitSuperMethodInvocation(SuperMethodInvocation node) {
     if (node.interfaceTarget == null) {
       return handleDynamicCall(environment.thisType, node.arguments);
     } else {
-      return handleCall(node.arguments, node.interfaceTarget.function,
+      return handleCall(node.arguments, node.interfaceTarget.getterType,
           receiver: getSuperReceiverType(node.interfaceTarget));
     }
   }
 
   @override
   DartType visitSuperPropertyGet(SuperPropertyGet node) {
     if (node.interfaceTarget == null) {
       return const DynamicType();
     } else {
       var receiver = getSuperReceiverType(node.interfaceTarget);
@@ skipping 305 matching lines @@
     }
   }
 
   @override
   visitFieldInitializer(FieldInitializer node) {
     node.value = checkAndDowncastExpression(node.value, node.field.type);
   }
 
   @override
   visitRedirectingInitializer(RedirectingInitializer node) {
-    handleCall(node.arguments, node.target.function,
+    handleCall(node.arguments, node.target.getterType,
         typeParameters: const <TypeParameter>[]);
   }
 
   @override
   visitSuperInitializer(SuperInitializer node) {
-    handleCall(node.arguments, node.target.function,
+    handleCall(node.arguments, node.target.getterType,
         typeParameters: const <TypeParameter>[],
         receiver: getSuperReceiverType(node.target));
   }
 
   @override
   visitLocalInitializer(LocalInitializer node) {
     visitVariableDeclaration(node.variable);
   }
 
   @override
   visitInvalidInitializer(InvalidInitializer node) {}
 }