static bool EligibleForSpecialMarkerTypeUsage(Instantiation inst, MethodTable* pOwnerMT);

if (retryWithExactInterfaces)

duplicates |= InsertMethodTable(intIt.GetInterface(pNewIntfMT, CLASS_LOAD_EXACTPARENTS), pExactMTs, nInterfacesCount, &nAssigned);

}

else

{

MethodTable *pItfPossiblyApprox = intIt.GetInterfaceApprox();

// pItfPossiblyApprox can be in 4 situations

// 1. It has no instantiation

// 2. It is a special marker type, AND pNewItfMT is a special marker type. Compute the exact instantiation as containing entirely a list of types corresponding to calling GetSpecialInstantiationType on pMT (This rule works based on the current behavior of GetSpecialInstantiationType where it treats all interfaces the same)

// 3. It is a special marker type, but pNewItfMT is NOT a special marker type. Compute the exact instantiation as containing entirely a list of types corresponding to calling GetSpecialInstantiationType on pNewItfMT

// 4. It is an exact instantiation

//

// NOTE: pItfPossiblyApprox must not be considered a special marker type if pNewItfMT has the MayHaveOpenInterfacesInInterfaceMap flag set

//

// Then determine if all of the following conditions hold true.

// 1. All generic arguments are the same (always true for cases 2 and 3 above)

// 2. The first generic argument in the instantiation is exactly the value of calling GetSpecialInstantiationType on pMT (always true for case 2)

//

// If so, then we should insert the special marker type

// Otherwise, we should insert the exact instantiation of the interface

// HOWEVER: If the exact instantiation IS a special marker interface, we need to retry with exact interfaces to avoid ambiguity situations

//

// NOTE: This is also part of the logic which determines if we need to call SetMayHaveOpenInterfacesInInterfaceMap. The CLR type system has a bug in its structure

// such that if you attempt to instantiate a type over its own type parameter from the open type, we will load the GenericTypeDefinition instead of loading

// a type explicitly instantiated over those type parameters. We re-use the GenericTypeDefinition as the special marker type, which leads to a conflict

// when something like that happens. So, we need to detect when something like that happens, and set the MayHaveOpenInterfacesInInterfaceMap flag,

// and avoid using the special marker type in those situations.

MethodTable *pItfToInsert = NULL;

bool intendedExactMatch = false;

if (!pItfPossiblyApprox->HasInstantiation())

{

// case 1

pItfToInsert = pItfPossiblyApprox;

intendedExactMatch = true;

}

else if (pItfPossiblyApprox->IsSpecialMarkerTypeForGenericCasting() && !pNewIntfMT->GetAuxiliaryData()->MayHaveOpenInterfacesInInterfaceMap())

// We are in case 2 or 3 above

bool pNewIntfMTIsSpecialMarkerType = pNewIntfMT->IsSpecialMarkerTypeForGenericCasting() && !pMT->GetAuxiliaryData()->MayHaveOpenInterfacesInInterfaceMap();

if (pNewIntfMTIsSpecialMarkerType)

{

// case 2

pItfToInsert = pItfPossiblyApprox; // We have the special marker type already, so this is what we insert

}

else

{

// case 3

bool mustUseSpecialMarkerType = pNewIntfMT->GetSpecialInstantiationType() == pMT->GetSpecialInstantiationType();

if (mustUseSpecialMarkerType)

{

pItfToInsert = pItfPossiblyApprox; // We have the special marker type already, so this is what we insert

}

else

{

pItfToInsert = intIt.GetInterface(pNewIntfMT, CLASS_LOAD_EXACTPARENTS);

intendedExactMatch = true;

}

}

// case 4 (We have an exact interface)

if (ClassLoader::EligibleForSpecialMarkerTypeUsage(pItfPossiblyApprox->GetInstantiation(), pMT))

{

// Validated that all generic arguments are the same, and that the first generic argument in the instantiation is exactly the value of calling GetSpecialInstantiationType on pMT

// Then use the special marker type here

pItfToInsert = ClassLoader::LoadTypeDefThrowing(pItfPossiblyApprox->GetModule(), pItfPossiblyApprox->GetCl(), ClassLoader::ThrowIfNotFound, ClassLoader::PermitUninstDefOrRef, 0, CLASS_LOAD_EXACTPARENTS).AsMethodTable();

}

else

{

pItfToInsert = pItfPossiblyApprox;

intendedExactMatch = true;

}

if (pItfToInsert->IsSpecialMarkerTypeForGenericCasting())

{

if (intendedExactMatch)

{

// We are trying to insert a special marker type into the interface list, but it is exactly the same as the exact instantiation we should actually want, we need to set the

// MayHaveOpenInterfacesInInterfaceMap flag, so trigger the retry logic.

retry = true;

break;

}

else if (pMT->GetSpecialInstantiationType() == pItfToInsert->GetInstantiation()[0])

{

// We are trying to insert a special marker type into the interface list, but the first generic argument

// in the instantiation is exactly the value of calling GetSpecialInstantiationType on pMT.

// This implies that the special marker type is actually the exact instantiation that we should be using, which

// will cause the same ambiguity situation as above. Trigger a retry, which will set MayHaveOpenInterfacesInInterfaceMap

// and disable the special marker type behavior for this type.

retry = true;

break;

}

}

if (!intendedExactMatch)

{

_ASSERTE(pItfToInsert->IsSpecialMarkerTypeForGenericCasting());

}

duplicates |= InsertMethodTable(pItfToInsert, pExactMTs, nInterfacesCount, &nAssigned);

if (duplicates || (nAssigned != pMT->GetNumInterfaces()))

if (ClassLoader::EligibleForSpecialMarkerTypeUsage(genericLoadInst, pMTInterfaceMapOwner))

if (thRet.AsMethodTable()->GetInstantiation()[0] == pMTInterfaceMapOwner->GetSpecialInstantiationType())

{

// We loaded the special marker type, but it is ALSO the exact expected type which isn't a valid combination

// In this case return something else (object) to indicate that

// we found an invalid situation and this function should be retried without the special marker type logic enabled.

thRet = TypeHandle(g_pObjectClass);

break;

}

thRet = TypeHandle(g_pObjectClass);

LIMITED_METHOD_DAC_CONTRACT;

<PropertyGroup>

<!-- The SDK for VB.NET requires the DefineConstants variable to be , delimited instead of ; -->

<DefineConstants Condition="'$(MSBuildProjectExtension)' == '.vbproj'">$(DefineConstants.Replace(';',','))</DefineConstants>

</PropertyGroup>