Add type inference for null-aware method invocations.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.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 file.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 35 matching lines @@
   if (arguments is KernelArguments) {
     return arguments._hasExplicitTypeArguments ? arguments.types : null;
   } else {
     // This code path should only be taken in situations where there are no
     // type arguments at all, e.g. calling a user-definable operator.
     assert(arguments.types.isEmpty);
     return null;
   }
 }
 
-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, '~');
-}
-
 /// Concrete shadow object representing a set of invocation arguments.
 class KernelArguments extends Arguments {
   bool _hasExplicitTypeArguments;
 
   KernelArguments(List<Expression> positional,
       {List<DartType> types, List<NamedExpression> named})
       : _hasExplicitTypeArguments = types != null && types.isNotEmpty,
         super(positional, types: types, named: named);
 
   static void setExplicitArgumentTypes(
@@ skipping 1258 matching lines @@
   KernelMethodInvocation(Expression receiver, Name name, Arguments arguments,
       {bool isImplicitCall: false, Member interfaceTarget})
       : _isImplicitCall = isImplicitCall,
         super(receiver, name, arguments, interfaceTarget);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // The inference dependencies are the inference dependencies of the
     // receiver.
     collector.collectDependencies(receiver);
-    if (_isOverloadableArithmeticOperator(name.name)) {
+    if (isOverloadableArithmeticOperator(name.name)) {
       collector.collectDependencies(arguments.positional[0]);
     }
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
-    typeNeeded = inferrer.listener.methodInvocationEnter(this, typeContext) ||
-        typeNeeded;
-    // First infer the receiver so we can look up the method that was invoked.
-    var receiverType = inferrer.inferExpression(receiver, null, true);
-    bool isOverloadedArithmeticOperator = false;
-    Member interfaceMember =
-        inferrer.findMethodInvocationMember(receiverType, this);
-    if (interfaceMember is Procedure) {
-      isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
-          .isOverloadedArithmeticOperatorAndType(interfaceMember, receiverType);
-    }
-    var calleeType = inferrer.getCalleeFunctionType(
-        interfaceMember, receiverType, name, !_isImplicitCall);
-    bool forceArgumentInference = false;
-    if (inferrer.isDryRun) {
-      if (_isUserDefinableOperator(name.name)) {
-        // If this is an overloadable arithmetic operator, then type inference
-        // might depend on the RHS, so conservatively assume it does.
-        forceArgumentInference = _isOverloadableArithmeticOperator(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(arguments) == null;
-      }
-    }
-    var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
-        fileOffset, calleeType, calleeType.returnType, arguments,
-        isOverloadedArithmeticOperator: isOverloadedArithmeticOperator,
-        receiverType: receiverType,
-        forceArgumentInference: forceArgumentInference);
-    inferrer.listener.methodInvocationExit(this, inferredType);
-    return inferredType;
+    return inferrer.inferMethodInvocation(this, receiver, fileOffset, this,
+        _isImplicitCall, typeContext, typeNeeded);
   }
 }
 
 /// Shadow object for [Not].
 class KernelNot extends Not implements KernelExpression {
   KernelNot(Expression operand) : super(operand);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     collector.collectDependencies(operand);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.notEnter(this, typeContext) || typeNeeded;
     // First infer the receiver so we can look up the method that was invoked.
     var boolType = inferrer.coreTypes.boolClass.rawType;
     inferrer.inferExpression(operand, boolType, false);
     DartType inferredType = typeNeeded ? boolType : null;
     inferrer.listener.notExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete shadow object representing a null-aware method invocation.
+///
+/// A null-aware method invocation of the form `a?.b(...)` is represented as the
+/// expression:
+///
+///     let v = a in v == null ? null : v.b(...)
+class KernelNullAwareMethodInvocation extends Let implements KernelExpression {
+  KernelNullAwareMethodInvocation(VariableDeclaration variable, Expression body)
+      : super(variable, body);
+
+  @override
+  ConditionalExpression get body => super.body;
+
+  MethodInvocation get _desugaredInvocation => body.otherwise;
+
+  @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Null aware expressions are not immediately evident.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    var inferredType = inferrer.inferMethodInvocation(
+        this,
+        variable.initializer,
+        fileOffset,
+        _desugaredInvocation,
+        false,
+        typeContext,
+        true,
+        receiverVariable: variable);
+    body.staticType = inferredType;
+    return inferredType;
+  }
+}
+
 /// Concrete shadow object representing a null-aware read from a property.
 ///
 /// A null-aware property get of the form `a?.b` is represented as the kernel
 /// expression:
 ///
 ///     let v = a in v == null ? null : v.b
 class KernelNullAwarePropertyGet extends Let implements KernelExpression {
   KernelNullAwarePropertyGet(
       VariableDeclaration variable, ConditionalExpression body)
       : super(variable, body);
@@ skipping 848 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }