public Key(EEType *pSourceType, EEType *pTargetType, AssignmentVariation variation)
{
Debug.Assert((((long)pSourceType) & 3) == 0, "misaligned EEType!");
Debug.Assert(((uint)variation) <= 3, "variation enum has an unexpectedly large value!");
_sourceTypeAndVariation = (IntPtr)(((byte *)pSourceType) + ((int)variation));
_targetType = (IntPtr)pTargetType;
}
public Key(EEType* pSourceType, EEType* pTargetType, AssignmentVariation variation)
{
Debug.Assert((((long)pSourceType) & 3) == 0, "misaligned EEType!");
Debug.Assert(((uint)variation) <= 3, "variation enum has an unexpectedly large value!");
_sourceTypeAndVariation = (IntPtr)(((byte*)pSourceType) + ((int)variation));
_targetType = (IntPtr)pTargetType;
}
// Internally callable version of the export method above. Has two additional flags:
// fBoxedSource : assume the source type is boxed so that value types and enums are
// compatible with Object, ValueType and Enum (if applicable)
// fAllowSizeEquivalence : allow identically sized integral types and enums to be considered
// equivalent (currently used only for array element types)
static internal unsafe bool AreTypesAssignableInternal(EEType* pSourceType, EEType* pTargetType, AssignmentVariation variation)
{
bool fBoxedSource = ((variation & AssignmentVariation.BoxedSource) == AssignmentVariation.BoxedSource);
bool fAllowSizeEquivalence = ((variation & AssignmentVariation.AllowSizeEquivalence ) == AssignmentVariation.AllowSizeEquivalence);
//
// Are the types identical?
//
if (AreTypesEquivalentInternal(pSourceType, pTargetType))
return true;
//
// Handle cast to interface cases.
//
if (pTargetType->IsInterface)
{
// Value types can only be cast to interfaces if they're boxed.
if (!fBoxedSource && pSourceType->IsValueType)
return false;
if (ImplementsInterface(pSourceType, pTargetType))
return true;
// Are the types compatible due to generic variance?
if (pTargetType->HasGenericVariance && pSourceType->HasGenericVariance)
return TypesAreCompatibleViaGenericVariance(pSourceType, pTargetType);
return false;
}
if (pSourceType->IsInterface)
{
// The only non-interface type an interface can be cast to is Object.
return WellKnownEETypes.IsSystemObject(pTargetType);
}
//
// Handle cast to array or pointer cases.
//
if (pTargetType->IsParameterizedType)
{
if (pSourceType->IsParameterizedType
&& (pTargetType->ParameterizedTypeShape == pSourceType->ParameterizedTypeShape))
{
// Source type is also a parameterized type. Are the parameter types compatible?
if (pSourceType->RelatedParameterType->IsPointerType)
{
// If the parameter types are pointers, then only exact matches are correct.
// As we've already called AreTypesEquivalent at the start of this function,
// return false as the exact match case has already been handled.
// int** is not compatible with uint**, nor is int*[] oompatible with uint*[].
return false;
}
else
{
// Note that using AreTypesAssignableInternal with AssignmentVariation.AllowSizeEquivalence
// here handles array covariance as well as IFoo[] -> Foo[] etc. We are not using
// AssignmentVariation.BoxedSource because int[] is not assignable to object[].
return CastCache.AreTypesAssignableInternal(pSourceType->RelatedParameterType,
pTargetType->RelatedParameterType, AssignmentVariation.AllowSizeEquivalence);
}
}
// Can't cast a non-parameter type to a parameter type or a parameter type of different shape to a parameter type
return false;
}
if (pSourceType->IsArray)
{
// Target type is not an array. But we can still cast arrays to Object or System.Array.
return WellKnownEETypes.IsSystemObject(pTargetType) || WellKnownEETypes.IsSystemArray(pTargetType);
}
else if (pSourceType->IsParameterizedType)
{
return false;
}
//
// Handle cast to other (non-interface, non-array) cases.
//
if (pSourceType->IsValueType)
{
// Certain value types of the same size are treated as equivalent when the comparison is
// between array element types (indicated by fAllowSizeEquivalence). These are integer types
// of the same size (e.g. int and uint) and the base type of enums vs all integer types of the
// same size.
if (fAllowSizeEquivalence && pTargetType->IsValueType)
{
if (ArePrimitveTypesEquivalentSize(pSourceType, pTargetType))
return true;
// Non-identical value types aren't equivalent in any other case (since value types are
// sealed).
return false;
}
// If the source type is a value type but it's not boxed then we've run out of options: the types
// are not identical, the target type isn't an interface and we're not allowed to check whether
// the target type is a parent of this one since value types are sealed and thus the only matches
// would be against Object, ValueType or Enum, all of which are reference types and not compatible
// with non-boxed value types.
if (!fBoxedSource)
return false;
}
// Sub case of casting between two instantiations of the same delegate type where one or more of
// the type parameters have variance. Only interfaces and delegate types can have variance over
// their type parameters and we know that neither type is an interface due to checks above.
if (pTargetType->HasGenericVariance && pSourceType->HasGenericVariance)
{
// We've dealt with the identical case at the start of this method. And the regular path below
// will handle casting to Object, Delegate and MulticastDelegate. Since we don't support
// deriving from user delegate classes any further all we have to check here is that the
// uninstantiated generic delegate definitions are the same and the type parameters are
// compatible.
return TypesAreCompatibleViaGenericVariance(pSourceType, pTargetType);
}
// Is the source type derived from the target type?
if (IsDerived(pSourceType, pTargetType))
return true;
return false;
}
public unsafe static bool AreTypesAssignableInternal(EEType* pSourceType, EEType* pTargetType, AssignmentVariation variation)
{
// Important special case -- it breaks infinite recursion in CastCache itself!
if (pSourceType == pTargetType)
return true;
Key key = new Key(pSourceType, pTargetType, variation);
Entry entry = LookupInCache(s_cache, ref key);
if (entry == null)
return CacheMiss(ref key);
return entry.Result;
}
public static unsafe bool AreTypesAssignableInternal(EEType *pSourceType, EEType *pTargetType, AssignmentVariation variation, EETypePairList *pVisited)
{
// Important special case -- it breaks infinite recursion in CastCache itself!
if (pSourceType == pTargetType)
{
return(true);
}
Key key = new Key(pSourceType, pTargetType, variation);
Entry entry = LookupInCache(s_cache, ref key);
if (entry == null)
{
return(CacheMiss(ref key, pVisited));
}
return(entry.Result);
}
