|
public GetGenericInferenceType ( |
||
| dynamicObject | ||
| return | ||
/// <summary>
/// Provides generic type inference for a single parameter.
/// </summary>
/// <remarks>
/// For example:
/// M{T}(T x)
/// M{T}(IList{T} x)
/// M{T}(ref T x)
/// M{T}(T[] x)
/// M{T}(ref Dictionary{T,T}[] x)
/// </remarks>
internal static Type GetInferedType(OverloadResolver/*!*/ resolver, Type/*!*/ genericParameter, Type/*!*/ parameterType,
DynamicMetaObject/*!*/ input, Dictionary<Type, Type>/*!*/ binding, Dictionary<DynamicMetaObject, BindingRestrictions>/*!*/ restrictions) {
if (parameterType.IsSubclassOf(typeof(Delegate))) {
// see if we have an invokable object which can be used to infer into this delegate
IInferableInvokable invokeInfer = input as IInferableInvokable;
if (invokeInfer != null) {
InferenceResult inference = invokeInfer.GetInferredType(parameterType, genericParameter);
if (inference != null) {
if (inference.Restrictions != BindingRestrictions.Empty) {
restrictions[input] = inference.Restrictions;
}
binding[genericParameter] = inference.Type;
if (ConstraintsViolated(inference.Type, genericParameter, binding)) {
return null;
}
return inference.Type;
}
}
}
return GetInferedType(genericParameter, parameterType, resolver.GetGenericInferenceType(input), input.LimitType, binding);
}
public override Type GetInferedType(OverloadResolver resolver, Type genericParameter, DynamicMetaObject input, Dictionary<Type, Type> prevConstraints, Dictionary<DynamicMetaObject, BindingRestrictions> restrictions) {
Type inputType = resolver.GetGenericInferenceType(input);
if (inputType != null) {
prevConstraints[genericParameter] = inputType;
if (ConstraintsViolated(inputType, genericParameter, prevConstraints)) {
return null;
}
}
return inputType;
}
public override Type GetInferedType(OverloadResolver resolver, Type genericParameter, DynamicMetaObject input, Dictionary<Type, Type> prevConstraints, Dictionary<DynamicMetaObject, BindingRestrictions> restrictions) {
Type inputType = resolver.GetGenericInferenceType(input);
if (ParameterType.IsInterface) {
//
// The argument can implement multiple instantiations of the same generic interface definition, e.g.
// ArgType : I<C<X>>, I<D<Y>>
// ParamType == I<C<T>>
//
// Unless X == Y we can't infer T.
//
Type[] interfaces = inputType.GetInterfaces();
Type match = null;
Type genTypeDef = ParameterType.GetGenericTypeDefinition();
foreach (Type ifaceType in interfaces) {
if (ifaceType.IsGenericType && ifaceType.GetGenericTypeDefinition() == genTypeDef) {
if (!MatchGenericParameter(genericParameter, ifaceType, ParameterType, prevConstraints, ref match)) {
return null;
}
}
}
prevConstraints[genericParameter] = match;
return match;
} else if (ParameterType.IsArray) {
return prevConstraints[genericParameter] = MatchGenericParameter(genericParameter, input.LimitType, ParameterType, prevConstraints);
} else if (ParameterType.IsByRef) {
Type argType = input.LimitType;
if (CompilerHelpers.IsStrongBox(argType)) {
argType = argType.GetGenericArguments()[0];
}
return prevConstraints[genericParameter] = MatchGenericParameter(genericParameter, argType, ParameterType.GetElementType(), prevConstraints);
} else if (ParameterType.IsSubclassOf(typeof(Delegate))) {
// see if we have an invokable object which can be used to infer into this delegate
IInferableInvokable invokeInfer = input as IInferableInvokable;
if (invokeInfer != null) {
InferenceResult inference = invokeInfer.GetInferredType(ParameterType, genericParameter);
if (inference != null) {
if (inference.Restrictions != BindingRestrictions.Empty) {
restrictions[input] = inference.Restrictions;
}
prevConstraints[genericParameter] = inference.Type;
if (ConstraintsViolated(inference.Type, genericParameter, prevConstraints)) {
return null;
}
return inference.Type;
}
}
}
// see if we're anywhere in our base class hierarchy
Type curType = input.LimitType;
Type genType = ParameterType.GetGenericTypeDefinition();
while (curType != typeof(object)) {
if (curType.IsGenericType && curType.GetGenericTypeDefinition() == genType) {
// TODO: Merge w/ the interface logic above
return prevConstraints[genericParameter] = MatchGenericParameter(genericParameter, curType, ParameterType, prevConstraints);
}
curType = curType.BaseType;
}
return null;
}
public override Type GetInferedType(OverloadResolver resolver, Type genericParameter, DynamicMetaObject input, Dictionary<Type, Type> prevConstraints, Dictionary<DynamicMetaObject, BindingRestrictions> restrictions) {
Type inputType = resolver.GetGenericInferenceType(input);
if (ParameterType.IsInterface) {
// see if we implement this interface exactly once
Type[] interfaces = inputType.GetInterfaces();
Type targetType = null;
Type genTypeDef = ParameterType.GetGenericTypeDefinition();
foreach (Type ifaceType in interfaces) {
if (ifaceType.IsGenericType && ifaceType.GetGenericTypeDefinition() == genTypeDef) {
if (targetType == null) {
// we may have a match, figure out the type...
targetType = InferGenericType(genericParameter, ifaceType, ParameterType, prevConstraints);
} else {
// multiple interface implementations match
return null;
}
}
}
prevConstraints[genericParameter] = targetType;
return targetType;
} else if (ParameterType.IsSubclassOf(typeof(Delegate))) {
// see if we have an invokable object which can be used to infer into this delegate
IInferableInvokable invokeInfer = input as IInferableInvokable;
if (invokeInfer != null) {
InferenceResult inference = invokeInfer.GetInferredType(ParameterType, genericParameter);
if (inference != null) {
if (inference.Restrictions != BindingRestrictions.Empty) {
restrictions[input] = inference.Restrictions;
}
prevConstraints[genericParameter] = inference.Type;
if (ConstraintsViolated(inference.Type, genericParameter, prevConstraints)) {
return null;
}
return inference.Type;
}
}
}
// see if we're anywhere in our base class hierarchy
Type curType = input.LimitType;
Type genType = ParameterType.GetGenericTypeDefinition();
while (curType != typeof(object)) {
if (curType.IsGenericType) {
if (curType.GetGenericTypeDefinition() == genType) {
// TODO: Merge w/ the interface logic above
Type unboundType = ParameterType;
Type res = InferGenericType(genericParameter, curType, unboundType, prevConstraints);
prevConstraints[genericParameter] = res;
return res;
}
}
curType = curType.BaseType;
}
return null;
}
