Fix corner cases of type inference with implicit references to `.call`.

pkg/front_end/lib/src/fasta/kernel/fasta_accessors.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 fasta.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelArguments, KernelThisExpression;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
@@ skipping 87 matching lines @@
       List<TypeParameter> typeParameters);
 
   StaticGet makeStaticGet(Member readTarget, Token token);
 
   dynamic addCompileTimeError(int charOffset, String message, {bool silent});
 
   bool isIdentical(Member member);
 
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
-      {bool isConstantExpression, bool isNullAware});
+      {bool isConstantExpression, bool isNullAware, bool isImplicitCall});
 
   DartType validatedTypeVariableUse(
       TypeParameterType type, int offset, bool nonInstanceAccessIsError);
 
   void warning(String message, [int charOffset]);
 }
 
 abstract class FastaAccessor implements Accessor {
   BuilderHelper get helper;
 
@@ skipping 211 matching lines @@
             helper, send.token, send.name, null, null);
       }
     }
   }
 
   doInvocation(int offset, Arguments arguments) {
     if (isInitializer) {
       return buildConstructorInitializer(offset, new Name(""), arguments);
     } else {
       return helper.buildMethodInvocation(
-          new KernelThisExpression(), callName, arguments, offset);
+          new KernelThisExpression(), callName, arguments, offset,
+          isImplicitCall: true);
     }
   }
 
   Initializer buildConstructorInitializer(
       int offset, Name name, Arguments arguments) {
     Constructor constructor = helper.lookupConstructor(name, isSuper: isSuper);
     if (constructor == null ||
         !helper.checkArguments(
             constructor.function, arguments, <TypeParameter>[])) {
       return helper.buildInvalidInitializer(
@@ skipping 207 matching lines @@
   IndexAccessor.internal(this.helper, Token token, Expression receiver,
       Expression index, Procedure getter, Procedure setter)
       : super.internal(helper, receiver, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(
-      buildSimpleRead(),
-      callName,
-      arguments,
-      offset,
-    );
+        buildSimpleRead(), callName, arguments, offset,
+        isImplicitCall: true);
   }
 
   toString() => "IndexAccessor()";
 
   static FastaAccessor make(
       BuilderHelper helper,
       Token token,
       Expression receiver,
       Expression index,
       Procedure getter,
@@ skipping 76 matching lines @@
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (helper.constantExpressionRequired && !helper.isIdentical(readTarget)) {
       helper.addCompileTimeError(offset, "Not a constant expression.");
     }
     if (readTarget == null || isFieldOrGetter(readTarget)) {
       return helper.buildMethodInvocation(buildSimpleRead(), callName,
           arguments, offset + (readTarget?.name?.name?.length ?? 0),
           // This isn't a constant expression, but we have checked if a
           // constant expression error should be emitted already.
-          isConstantExpression: true);
+          isConstantExpression: true,
+          isImplicitCall: true);
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "StaticAccessor()";
 }
 
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with FastaAccessor {
   SuperPropertyAccessor(BuilderHelper helper, Token token, Name name,
       Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (helper.constantExpressionRequired) {
       helper.addCompileTimeError(offset, "Not a constant expression.");
     }
     if (getter == null || isFieldOrGetter(getter)) {
       return helper.buildMethodInvocation(
           buildSimpleRead(), callName, arguments, offset,
           // This isn't a constant expression, but we have checked if a
           // constant expression error should be emitted already.
-          isConstantExpression: true);
+          isConstantExpression: true,
+          isImplicitCall: true);
     } else {
       return new DirectMethodInvocation(new ThisExpression(), getter, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
   ThisIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Procedure getter, Procedure setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, offset);
+        buildSimpleRead(), callName, arguments, offset,
+        isImplicitCall: true);
   }
 
   toString() => "ThisIndexAccessor()";
 }
 
 class SuperIndexAccessor extends kernel.SuperIndexAccessor with FastaAccessor {
   SuperIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Member getter, Member setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, offset);
+        buildSimpleRead(), callName, arguments, offset,
+        isImplicitCall: true);
   }
 
   toString() => "SuperIndexAccessor()";
 }
 
 class ThisPropertyAccessor extends kernel.ThisPropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   ThisPropertyAccessor(
@@ skipping 44 matching lines @@
 class VariableAccessor extends kernel.VariableAccessor with FastaAccessor {
   VariableAccessor(
       BuilderHelper helper, Token token, VariableDeclaration variable,
       [DartType promotedType])
       : super(helper, variable, promotedType, token);
 
   String get plainNameForRead => variable.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
-        adjustForImplicitCall(plainNameForRead, offset));
+        adjustForImplicitCall(plainNameForRead, offset),
+        isImplicitCall: true);
   }
 
   toString() => "VariableAccessor()";
 }
 
 class ReadOnlyAccessor extends kernel.ReadOnlyAccessor with FastaAccessor {
   final String plainNameForRead;
 
   ReadOnlyAccessor(BuilderHelper helper, Expression expression,
       this.plainNameForRead, Token token)
       : super(helper, expression, token);
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
-        adjustForImplicitCall(plainNameForRead, offset));
+        adjustForImplicitCall(plainNameForRead, offset),
+        isImplicitCall: true);
   }
 }
 
 class ParenthesizedExpression extends ReadOnlyAccessor {
   ParenthesizedExpression(
       BuilderHelper helper, Expression expression, Token token)
       : super(helper, expression, null, token);
 
   Expression makeInvalidWrite(Expression value) {
     return helper.buildCompileTimeError(
@@ skipping 110 matching lines @@
       {bool isGetter: false, bool isSetter: false, int offset}) {
     return helper.throwNoSuchMethodError(
         plainNameForRead, arguments, offset ?? offsetForToken(this.token),
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }