anchor.diff:        void forEachArgument(void callback(String name, Expression expression)),
         void setInferredTypeArguments(List<DartType> types)) {
       typeNeeded = listener.constructorInvocationEnter(typeContext) || typeNeeded;
  -    List<DartType> inferredTypes;
  -    FunctionType constructorType = target.function.functionType;
  -    Substitution substitution;
  -    List<DartType> formalTypes;
  -    List<DartType> actualTypes;
  -    var targetClass = target.enclosingClass;
  -    var targetTypeParameters = targetClass.typeParameters;
  -    bool inferenceNeeded = explicitTypeArguments == null &&
  -        strongMode &&
  -        targetTypeParameters.isNotEmpty;
  -    if (inferenceNeeded) {
  -      inferredTypes = new List<DartType>.filled(
  -          targetTypeParameters.length, const UnknownType());
  -      typeSchemaEnvironment.inferGenericFunctionOrType(targetClass.thisType,
  -          targetClass.typeParameters, null, null, typeContext, inferredTypes);
  -      substitution =
  -          Substitution.fromPairs(targetTypeParameters, inferredTypes);
  -      formalTypes = [];
  -      actualTypes = [];
  -    } else if (explicitTypeArguments != null) {
  -      substitution =
  -          Substitution.fromPairs(targetTypeParameters, explicitTypeArguments);
  -    }
  -    int i = 0;
  -    forEachArgument((name, expression) {
  -      DartType formalType = name != null
  -          ? _getNamedParameterType(constructorType, name)
  -          : _getPositionalParameterType(constructorType, i++);
  -      DartType inferredFormalType = substitution != null
  -          ? substitution.substituteType(formalType)
  -          : formalType;
  -      var expressionType =
  -          inferExpression(expression, inferredFormalType, inferenceNeeded);
  -      if (inferenceNeeded) {
  -        formalTypes.add(formalType);
  -        actualTypes.add(expressionType);
  -      }
  -    });
  -    if (inferenceNeeded) {
  -      typeSchemaEnvironment.inferGenericFunctionOrType(
  -          targetClass.thisType,
  -          targetClass.typeParameters,
  -          formalTypes,
  -          actualTypes,
  -          typeContext,
  -          inferredTypes);
  -      substitution =
  -          Substitution.fromPairs(targetTypeParameters, inferredTypes);
  -      instrumentation?.record(Uri.parse(uri), offset, 'typeArgs',
  -          new InstrumentationValueForTypeArgs(inferredTypes));
  -      setInferredTypeArguments(inferredTypes);
  -    }
  -    DartType inferredType;
  -    if (typeNeeded) {
  -      inferredType = substitution == null
  -          ? targetClass.rawType
  -          : substitution.substituteType(targetClass.thisType);
  -    }
  +    var inferredType = _inferInvocation(
  +        typeContext,
  +        typeNeeded,
  +        offset,
  +        target.function.functionType,
  +        target.enclosingClass.thisType,
  +        explicitTypeArguments,
  +        forEachArgument,
  +        setInferredTypeArguments);
       listener.constructorInvocationExit(inferredType);
       return inferredType;
     }
  
positive.code:     }
    }
  
    DartType _wrapType(DartType type, Class class_) {
      return new InterfaceType(class_, <DartType>[type]);
    }
  
negative.code:             .isOverloadedArithmeticOperator(interfaceMember);
        }
      }
      var calleeType = _getCalleeFunctionType(
          interfaceMember, receiverType, methodName, offset);
      var inferredType = _inferInvocation(
          typeContext,
          typeNeeded,
          offset,
          calleeType,
          calleeType.returnType,
          explicitTypeArguments,
          forEachArgument,
          setInferredTypeArguments,
          isOverloadedArithmeticOperator: isOverloadedArithmeticOperator,
          receiverType: receiverType);
      listener.methodInvocationExit(inferredType);
      return inferredType;
    }
  