fix #26992, inference failures are now an error

pkg/analyzer/lib/src/generated/static_type_analyzer.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1887 matching lines @@
 
   /**
    * Given a possibly generic invocation like `o.m(args)` or `(f)(args)` try to
    * infer the instantiated generic function type.
    *
    * This takes into account both the context type, as well as information from
    * the argument types.
    */
   void _inferGenericInvocationExpression(InvocationExpression node) {
     ArgumentList arguments = node.argumentList;
-    FunctionType inferred = _inferGenericInvoke(
-        node, node.function.staticType, node.typeArguments, arguments);
+    FunctionType inferred = _inferGenericInvoke(node, node.function.staticType,
+        node.typeArguments, arguments, node.function);
     if (inferred != null && inferred != node.staticInvokeType) {
       // Fix up the parameter elements based on inferred method.
       arguments.correspondingStaticParameters = ResolverVisitor
           .resolveArgumentsToParameters(arguments, inferred.parameters, null);
       node.staticInvokeType = inferred;
     }
   }
 
   /**
    * Given a possibly generic invocation or instance creation, such as
    * `o.m(args)` or `(f)(args)` or `new T(args)` try to infer the instantiated
    * generic function type.
    *
    * This takes into account both the context type, as well as information from
    * the argument types.
    */
-  FunctionType _inferGenericInvoke(Expression node, DartType fnType,
-      TypeArgumentList typeArguments, ArgumentList argumentList) {
+  FunctionType _inferGenericInvoke(
+      Expression node,
+      DartType fnType,
+      TypeArgumentList typeArguments,
+      ArgumentList argumentList,
+      AstNode errorNode) {
     TypeSystem ts = _typeSystem;
     if (typeArguments == null &&
         fnType is FunctionType &&
         fnType.typeFormals.isNotEmpty &&
         ts is StrongTypeSystemImpl) {
       // Get the parameters that correspond to the uninstantiated generic.
       List<ParameterElement> rawParameters = ResolverVisitor
           .resolveArgumentsToParameters(argumentList, fnType.parameters, null);
 
       List<DartType> paramTypes = <DartType>[];
@@ skipping 37 matching lines @@
               ..synthetic = true
               ..shareParameters(firstParamType.parameters)
               ..returnType = paramReturnType;
             function.type = new FunctionTypeImpl(function);
             // Use this as the expected 1st parameter type.
             paramTypes[0] = function.type;
           }
         }
       }
       return ts.inferGenericFunctionCall(_typeProvider, fnType, paramTypes,
-          argTypes, InferenceContext.getContext(node));
+          argTypes, InferenceContext.getContext(node),
+          errorReporter: _resolver.errorReporter, errorNode: errorNode);
     }
     return null;
   }
 
   /**
    * Given an instance creation of a possibly generic type, infer the type
    * arguments using the current context type as well as the argument types.
    */
   void _inferInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructor = node.constructorName;
@@ skipping 17 matching lines @@
 
     // Get back to the uninstantiated generic constructor.
     // TODO(jmesserly): should we store this earlier in resolution?
     // Or look it up, instead of jumping backwards through the Member?
     var rawElement = (originalElement as ConstructorMember).baseElement;
 
     FunctionType constructorType =
         _constructorToGenericFunctionType(rawElement);
 
     ArgumentList arguments = node.argumentList;
-    FunctionType inferred = _inferGenericInvoke(
-        node, constructorType, constructor.type.typeArguments, arguments);
+    FunctionType inferred = _inferGenericInvoke(node, constructorType,
+        constructor.type.typeArguments, arguments, node.constructorName);
 
     if (inferred != null && inferred != originalElement.type) {
       // Fix up the parameter elements based on inferred method.
       arguments.correspondingStaticParameters = ResolverVisitor
           .resolveArgumentsToParameters(arguments, inferred.parameters, null);
       inferConstructorName(constructor, inferred.returnType);
       // Update the static element as well. This is used in some cases, such as
       // computing constant values. It is stored in two places.
       constructor.staticElement =
           ConstructorMember.from(rawElement, inferred.returnType);
@@ skipping 367 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }