Add type inference for null-aware method 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/errors.dart' show internalError;
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/names.dart' show callName;
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
@@ skipping 26 matching lines @@
         SuperMethodInvocation,
         SuperPropertyGet,
         SuperPropertySet,
         TypeParameterType,
         VariableDeclaration,
         VoidType;
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/type_algebra.dart';
 
+bool isOverloadableArithmeticOperator(String name) {
+  return identical(name, '+') ||
+      identical(name, '-') ||
+      identical(name, '*') ||
+      identical(name, '%');
+}
+
+bool _isUserDefinableOperator(String name) {
+  return identical(name, '<') ||
+      identical(name, '>') ||
+      identical(name, '<=') ||
+      identical(name, '>=') ||
+      identical(name, '==') ||
+      identical(name, '-') ||
+      identical(name, '+') ||
+      identical(name, '/') ||
+      identical(name, '~/') ||
+      identical(name, '*') ||
+      identical(name, '%') ||
+      identical(name, '|') ||
+      identical(name, '^') ||
+      identical(name, '&') ||
+      identical(name, '<<') ||
+      identical(name, '>>') ||
+      identical(name, '[]=') ||
+      identical(name, '~');
+}
+
 /// Keeps track of information about the innermost function or closure being
 /// inferred.
 class ClosureContext {
   final bool isAsync;
 
   final bool isGenerator;
 
   final DartType returnContext;
 
   DartType _inferredReturnType;
@@ skipping 557 matching lines @@
     }
     DartType inferredType;
     if (typeNeeded) {
       inferredType = substitution == null
           ? returnType
           : substitution.substituteType(returnType);
     }
     return inferredType;
   }
 
+  /// Performs the core type inference algorithm for method invocations (this
+  /// handles both null-aware and non-null-aware method invocations).
+  DartType inferMethodInvocation(
+      Expression expression,
+      Expression receiver,
+      int fileOffset,
+      MethodInvocation desugaredInvocation,
+      bool isImplicitCall,
+      DartType typeContext,
+      bool typeNeeded,
+      {VariableDeclaration receiverVariable}) {
+    typeNeeded =
+        listener.methodInvocationEnter(expression, typeContext) || typeNeeded;
+    // First infer the receiver so we can look up the method that was invoked.
+    var receiverType = inferExpression(receiver, null, true);
+    receiverVariable?.type = receiverType;
+    bool isOverloadedArithmeticOperator = false;
+    Member interfaceMember =
+        findMethodInvocationMember(receiverType, desugaredInvocation);
+    if (interfaceMember is Procedure) {
+      isOverloadedArithmeticOperator = typeSchemaEnvironment
+          .isOverloadedArithmeticOperatorAndType(interfaceMember, receiverType);
+    }
+    var calleeType = getCalleeFunctionType(interfaceMember, receiverType,
+        desugaredInvocation.name, !isImplicitCall);
+    bool forceArgumentInference = false;
+    if (isDryRun) {
+      if (_isUserDefinableOperator(desugaredInvocation.name.name)) {
+        // If this is an overloadable arithmetic operator, then type inference
+        // might depend on the RHS, so conservatively assume it does.
+        forceArgumentInference =
+            isOverloadableArithmeticOperator(desugaredInvocation.name.name);
+      } else {
+        // If no type arguments were given, then type inference might depend on
+        // the arguments (because the called method might be generic), so
+        // conservatively assume it does.
+        forceArgumentInference =
+            getExplicitTypeArguments(desugaredInvocation.arguments) == null;
+      }
+    }
+    var inferredType = inferInvocation(typeContext, typeNeeded, fileOffset,
+        calleeType, calleeType.returnType, desugaredInvocation.arguments,
+        isOverloadedArithmeticOperator: isOverloadedArithmeticOperator,
+        receiverType: receiverType,
+        forceArgumentInference: forceArgumentInference);
+    listener.methodInvocationExit(expression, inferredType);
+    return inferredType;
+  }
+
   @override
   void inferParameterInitializer(
       Expression initializer, DartType declaredType) {
     assert(closureContext == null);
     inferExpression(initializer, declaredType, false);
   }
 
   /// Performs the core type inference algorithm for property gets (this handles
   /// both null-aware and non-null-aware property gets).
   DartType inferPropertyGet(
@@ skipping 109 matching lines @@
   void _forEachArgument(
       Arguments arguments, void callback(String name, Expression expression)) {
     for (var expression in arguments.positional) {
       callback(null, expression);
     }
     for (var namedExpression in arguments.named) {
       callback(namedExpression.name, namedExpression.value);
     }
   }
 }