Implement type inference of static invocations.

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

 // Copyright (c) 2017, 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.md file.
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
@@ skipping 529 matching lines @@
       int offset,
       Expression receiver,
       Name methodName,
       List<DartType> explicitTypeArguments,
       void forEachArgument(void callback(String name, Expression expression)),
       void setInferredTypeArguments(List<DartType> types),
       void setInterfaceTarget(Procedure procedure)) {
     typeNeeded = listener.methodInvocationEnter(typeContext) || typeNeeded;
     // First infer the receiver so we can look up the method that was invoked.
     var receiverType = inferExpression(receiver, null, true);
-    // TODO(paulberry): can we share some of the code below with
-    // inferConstructorInvocation?
     bool isOverloadedArithmeticOperator = false;
     Member interfaceMember;
     if (receiverType is InterfaceType) {
       interfaceMember =
           classHierarchy.getInterfaceMember(receiverType.classNode, methodName);
       if (interfaceMember is Procedure) {
         setInterfaceTarget(interfaceMember);
         isOverloadedArithmeticOperator = typeSchemaEnvironment
             .isOverloadedArithmeticOperator(interfaceMember);
       }
@@ skipping 49 matching lines @@
   /// [getterType] is the type of the field being referenced, or the return type
   /// of the getter.
   DartType inferStaticGet(
       DartType typeContext, bool typeNeeded, DartType getterType) {
     typeNeeded = listener.staticGetEnter(typeContext) || typeNeeded;
     var inferredType = typeNeeded ? getterType : null;
     listener.staticGetExit(inferredType);
     return inferredType;
   }
 
+  /// Performs the core type inference algorithm for method invocations.
+  ///
+  /// [typeContext], [typeNeeded], and the return value behave as described in
+  /// [inferExpression].
+  ///
+  /// [offset] is the location of the method invocation in the source file.
+  /// [receiver] is the object whose method is being invoked, and [methodName]
+  /// is the name of the method.  [explicitTypeArguments] is the set of type
+  /// arguments explicitly provided, or `null` if no type arguments were
+  /// provided.  [forEachArgument] is a callback which can be used to iterate
+  /// through all invocation arguments (both named and positional).
+  /// [setInferredTypeArguments] is a callback which can be used to record the
+  /// inferred type arguments.  [setInterfaceTarget] is a callback which can be
+  /// used to record the method being invoked.
+  DartType inferStaticInvocation(
+      DartType typeContext,
+      bool typeNeeded,
+      int offset,
+      Procedure target,
+      Name methodName,
+      List<DartType> explicitTypeArguments,
+      void forEachArgument(void callback(String name, Expression expression)),
+      void setInferredTypeArguments(List<DartType> types)) {
+    typeNeeded = listener.staticInvocationEnter(typeContext) || typeNeeded;
+    var calleeType = target.function.functionType;
+    var inferredType = _inferInvocation(
+        typeContext,
+        typeNeeded,
+        offset,
+        calleeType,
+        calleeType.returnType,
+        explicitTypeArguments,
+        forEachArgument,
+        setInferredTypeArguments);
+    listener.staticInvocationExit(inferredType);
+    return inferredType;
+  }
+
   /// Performs the core type inference algorithm for string concatenations.
   ///
   /// [typeContext], [typeNeeded], and the return value behave as described in
   /// [inferExpression].
   DartType inferStringConcatenation(
       DartType typeContext, bool typeNeeded, Iterable<Expression> expressions) {
     typeNeeded = listener.stringConcatenationEnter(typeContext) || typeNeeded;
     for (Expression expression in expressions) {
       inferExpression(expression, null, false);
     }
@@ skipping 151 matching lines @@
       typeSchemaEnvironment.inferGenericFunctionOrType(returnType,
           calleeTypeParameters, null, null, typeContext, inferredTypes);
       substitution =
           Substitution.fromPairs(calleeTypeParameters, inferredTypes);
       formalTypes = [];
       actualTypes = [];
     } else if (explicitTypeArguments != null &&
         calleeTypeParameters.length == explicitTypeArguments.length) {
       substitution =
           Substitution.fromPairs(calleeTypeParameters, explicitTypeArguments);
+    } else if (calleeTypeParameters.length != 0) {
+      substitution = Substitution.fromPairs(
+          calleeTypeParameters,
+          new List<DartType>.filled(
+              calleeTypeParameters.length, const DynamicType()));
     }
     int i = 0;
     forEachArgument((name, expression) {
       DartType formalType = name != null
           ? _getNamedParameterType(calleeType, name)
           : _getPositionalParameterType(calleeType, i++);
       DartType inferredFormalType = substitution != null
           ? substitution.substituteType(formalType)
           : formalType;
       var expressionType = inferExpression(expression, inferredFormalType,
@@ skipping 61 matching lines @@
   /// statement returning the given [type].
   void updateInferredReturnType(TypeInferrerImpl inferrer, DartType type) {
     if (_inferredReturnType == null) {
       _inferredReturnType = type;
     } else {
       _inferredReturnType = inferrer.typeSchemaEnvironment
           .getLeastUpperBound(_inferredReturnType, type);
     }
   }
 }