public bool NoExactMatch(ParseContext ec, MethodBase method)
{
var pd = TypeManager.GetParameterData(method);
var sourceType = pd.ExtensionMethodType;
if (sourceType != null)
{
var a = Arguments[0];
if (TypeManager.IsGenericType(sourceType) && TypeManager.ContainsGenericParameters(sourceType))
{
var tic = new TypeInferenceContext(sourceType.GetGenericArguments());
tic.OutputTypeInference(ec, a.Value, sourceType);
if (tic.FixAllTypes(ec))
{
sourceType = TypeManager.DropGenericTypeArguments(sourceType).MakeGenericType(tic.InferredTypeArguments);
}
}
if (!TypeManager.ImplicitConversionExists(ec, a.Value, sourceType))
{
ec.ReportError(
1936,
string.Format(
"An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
MethodGroup.Name,
TypeManager.GetCSharpName(a.Value.Type)),
Span);
return(true);
}
}
if (!method.IsGenericMethod)
{
return(false);
}
if (MethodGroup.Name == "SelectMany")
{
ec.ReportError(
1943,
string.Format(
"An expression type is incorrect in a subsequent 'from' clause in a query expression with source type '{0}'.",
Arguments[0].GetSignatureForError()),
Span);
}
else
{
ec.ReportError(
1942,
string.Format(
"An expression type in '{0}' clause is incorrect. Type inference failed in the call to '{1}'.",
MethodGroup.Name.ToLower(),
MethodGroup.Name),
Span);
}
return(true);
}
public bool NoExactMatch(ResolveContext ec, MethodBase method)
{
AParametersCollection pd = TypeManager.GetParameterData(method);
Type source_type = pd.ExtensionMethodType;
if (source_type != null)
{
Argument a = arguments [0];
if (TypeManager.IsGenericType(source_type) && TypeManager.ContainsGenericParameters(source_type))
{
#if GMCS_SOURCE
TypeInferenceContext tic = new TypeInferenceContext(TypeManager.GetTypeArguments(source_type));
tic.OutputTypeInference(ec, a.Expr, source_type);
if (tic.FixAllTypes(ec))
{
source_type = TypeManager.DropGenericTypeArguments(source_type).MakeGenericType(tic.InferredTypeArguments);
}
#else
throw new NotSupportedException();
#endif
}
if (!Convert.ImplicitConversionExists(ec, a.Expr, source_type))
{
ec.Report.Error(1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
mg.Name, TypeManager.CSharpName(a.Type));
return(true);
}
}
if (!TypeManager.IsGenericMethod(method))
{
return(false);
}
if (mg.Name == "SelectMany")
{
ec.Report.Error(1943, loc,
"An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'",
arguments [0].GetSignatureForError());
}
else
{
ec.Report.Error(1942, loc,
"An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'",
mg.Name.ToLower(), mg.Name);
}
return(true);
}
bool OverloadResolver.IErrorHandler.TypeInferenceFailed(ResolveContext rc, MemberSpec best)
{
var ms = (MethodSpec)best;
TypeSpec source_type = ms.Parameters.ExtensionMethodType;
if (source_type != null)
{
Argument a = arguments[0];
if (TypeManager.IsGenericType(source_type) && InflatedTypeSpec.ContainsTypeParameter(source_type))
{
TypeInferenceContext tic = new TypeInferenceContext(source_type.TypeArguments);
tic.OutputTypeInference(rc, a.Expr, source_type);
if (tic.FixAllTypes(rc))
{
source_type = source_type.GetDefinition().MakeGenericType(rc, tic.InferredTypeArguments);
}
}
if (!Convert.ImplicitConversionExists(rc, a.Expr, source_type))
{
rc.Report.Error(1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
best.Name, a.Type.GetSignatureForError());
return(true);
}
}
if (best.Name == "SelectMany")
{
rc.Report.Error(1943, loc,
"An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'",
arguments[0].GetSignatureForError());
}
else
{
rc.Report.Error(1942, loc,
"An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'",
best.Name.ToLowerInvariant(), best.Name);
}
return(true);
}
bool OverloadResolver.IErrorHandler.TypeInferenceFailed (ResolveContext rc, MemberSpec best)
{
var ms = (MethodSpec) best;
TypeSpec source_type = ms.Parameters.ExtensionMethodType;
if (source_type != null) {
Argument a = arguments[0];
if (TypeManager.IsGenericType (source_type) && TypeManager.ContainsGenericParameters (source_type)) {
TypeInferenceContext tic = new TypeInferenceContext (source_type.TypeArguments);
tic.OutputTypeInference (rc, a.Expr, source_type);
if (tic.FixAllTypes (rc)) {
source_type = source_type.GetDefinition ().MakeGenericType (tic.InferredTypeArguments);
}
}
if (!Convert.ImplicitConversionExists (rc, a.Expr, source_type)) {
rc.Report.Error (1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
best.Name, TypeManager.CSharpName (a.Type));
return true;
}
}
if (best.Name == "SelectMany") {
rc.Report.Error (1943, loc,
"An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'",
arguments[0].GetSignatureForError ());
} else {
rc.Report.Error (1942, loc,
"An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'",
best.Name.ToLowerInvariant (), best.Name);
}
return true;
}
public bool NoExactMatch (EmitContext ec, MethodBase method)
{
#if GMCS_SOURCE
AParametersCollection pd = TypeManager.GetParameterData (method);
Type source_type = pd.ExtensionMethodType;
if (source_type != null) {
Argument a = (Argument) Arguments [0];
if (source_type.IsGenericType && source_type.ContainsGenericParameters) {
TypeInferenceContext tic = new TypeInferenceContext (source_type.GetGenericArguments ());
tic.OutputTypeInference (ec, a.Expr, source_type);
if (tic.FixAllTypes ()) {
source_type = source_type.GetGenericTypeDefinition ().MakeGenericType (tic.InferredTypeArguments);
}
}
if (!Convert.ImplicitConversionExists (ec, a.Expr, source_type)) {
Report.Error (1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
mg.Name, TypeManager.CSharpName (a.Type));
return true;
}
}
if (!method.IsGenericMethod)
return false;
if (mg.Name == "SelectMany") {
Report.Error (1943, loc,
"An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'",
((Argument) Arguments [0]).GetSignatureForError ());
} else {
Report.Error (1942, loc,
"An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'",
mg.Name.ToLower (), mg.Name);
}
return true;
#else
return false;
#endif
}
public bool NoExactMatch(ResolveContext ec, MethodSpec method)
{
var pd = method.Parameters;
TypeSpec source_type = pd.ExtensionMethodType;
if (source_type != null) {
Argument a = arguments [0];
if (TypeManager.IsGenericType (source_type) && TypeManager.ContainsGenericParameters (source_type)) {
TypeInferenceContext tic = new TypeInferenceContext (source_type.TypeArguments);
tic.OutputTypeInference (ec, a.Expr, source_type);
if (tic.FixAllTypes (ec)) {
source_type = source_type.GetDefinition ().MakeGenericType (tic.InferredTypeArguments);
}
}
if (!Convert.ImplicitConversionExists (ec, a.Expr, source_type)) {
ec.Report.Error (1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
mg.Name, TypeManager.CSharpName (a.Type));
return true;
}
}
if (!method.IsGeneric)
return false;
if (mg.Name == "SelectMany") {
ec.Report.Error (1943, loc,
"An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'",
arguments [0].GetSignatureForError ());
} else {
ec.Report.Error (1942, loc,
"An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'",
mg.Name.ToLower (), mg.Name);
}
return true;
}
