//
// Infers type arguments based on explicit arguments
//
public bool ExplicitTypeInference (ResolveContext ec, TypeInferenceContext type_inference, TypeSpec delegate_type)
{
if (!HasExplicitParameters)
return false;
if (!delegate_type.IsDelegate) {
if (!delegate_type.IsExpressionTreeType)
return false;
delegate_type = TypeManager.GetTypeArguments (delegate_type) [0];
if (!delegate_type.IsDelegate)
return false;
}
AParametersCollection d_params = Delegate.GetParameters (delegate_type);
if (d_params.Count != Parameters.Count)
return false;
var ptypes = Parameters.Types;
var dtypes = d_params.Types;
for (int i = 0; i < Parameters.Count; ++i) {
if (type_inference.ExactInference (ptypes[i], dtypes[i]) == 0) {
//
// Continue when 0 (quick path) does not mean inference failure. Checking for
// same type handles cases like int -> int
//
if (ptypes[i] == dtypes[i])
continue;
return false;
}
}
return true;
}
//
// Implements method type arguments inference
//
bool InferInPhases (ResolveContext ec, TypeInferenceContext tic, AParametersCollection methodParameters)
{
int params_arguments_start;
if (methodParameters.HasParams) {
params_arguments_start = methodParameters.Count - 1;
} else {
params_arguments_start = arg_count;
}
TypeSpec [] ptypes = methodParameters.Types;
//
// The first inference phase
//
TypeSpec method_parameter = null;
for (int i = 0; i < arg_count; i++) {
Argument a = arguments [i];
if (a == null)
continue;
if (i < params_arguments_start) {
method_parameter = methodParameters.Types [i];
} else if (i == params_arguments_start) {
if (arg_count == params_arguments_start + 1 && TypeManager.HasElementType (a.Type))
method_parameter = methodParameters.Types [params_arguments_start];
else
method_parameter = TypeManager.GetElementType (methodParameters.Types [params_arguments_start]);
ptypes = (TypeSpec[]) ptypes.Clone ();
ptypes [i] = method_parameter;
}
//
// When a lambda expression, an anonymous method
// is used an explicit argument type inference takes a place
//
AnonymousMethodExpression am = a.Expr as AnonymousMethodExpression;
if (am != null) {
if (am.ExplicitTypeInference (ec, tic, method_parameter))
--score;
continue;
}
if (a.IsByRef) {
score -= tic.ExactInference (a.Type, method_parameter);
continue;
}
if (a.Expr.Type == InternalType.Null)
continue;
if (TypeManager.IsValueType (method_parameter)) {
score -= tic.LowerBoundInference (a.Type, method_parameter);
continue;
}
//
// Otherwise an output type inference is made
//
score -= tic.OutputTypeInference (ec, a.Expr, method_parameter);
}
//
// Part of the second phase but because it happens only once
// we don't need to call it in cycle
//
bool fixed_any = false;
if (!tic.FixIndependentTypeArguments (ec, ptypes, ref fixed_any))
return false;
return DoSecondPhase (ec, tic, ptypes, !fixed_any);
}
//
// Infers type arguments based on explicit arguments
//
public bool ExplicitTypeInference (ResolveContext ec, TypeInferenceContext type_inference, TypeSpec delegate_type)
{
if (!HasExplicitParameters)
return false;
if (!delegate_type.IsDelegate) {
if (!delegate_type.IsExpressionTreeType)
return false;
delegate_type = TypeManager.GetTypeArguments (delegate_type) [0];
if (!delegate_type.IsDelegate)
return false;
}
AParametersCollection d_params = Delegate.GetParameters (delegate_type);
if (d_params.Count != Parameters.Count)
return false;
for (int i = 0; i < Parameters.Count; ++i) {
TypeSpec itype = d_params.Types [i];
if (!TypeManager.IsGenericParameter (itype)) {
if (!TypeManager.HasElementType (itype))
continue;
if (!TypeManager.IsGenericParameter (TypeManager.GetElementType (itype)))
continue;
}
type_inference.ExactInference (Parameters.Types [i], itype);
}
return true;
}
//
// Infers type arguments based on explicit arguments
//
public bool ExplicitTypeInference (TypeInferenceContext type_inference, Type delegate_type)
{
if (!HasExplicitParameters)
return false;
if (!TypeManager.IsDelegateType (delegate_type)) {
#if GMCS_SOURCE
if (TypeManager.DropGenericTypeArguments (delegate_type) != TypeManager.expression_type)
return false;
delegate_type = delegate_type.GetGenericArguments () [0];
if (!TypeManager.IsDelegateType (delegate_type))
return false;
#else
return false;
#endif
}
AParametersCollection d_params = TypeManager.GetDelegateParameters (delegate_type);
if (d_params.Count != Parameters.Count)
return false;
for (int i = 0; i < Parameters.Count; ++i) {
Type itype = d_params.Types [i];
if (!TypeManager.IsGenericParameter (itype)) {
if (!TypeManager.HasElementType (itype))
continue;
if (!TypeManager.IsGenericParameter (itype.GetElementType ()))
continue;
}
type_inference.ExactInference (Parameters.Types [i], itype);
}
return true;
}
