|
public CreateArrayOfUnitTypes ( int cSize ) : |
||
| cSize | int | |
| return | ||
private void SetTypeArgsAll(TypeArray outerTypeArgs)
{
Debug.Assert(_pTypeArgsThis != null);
// Here we need to check our current type args. If we have an open placeholder,
// then we need to have all open placeholders, and we want to flush
// our outer type args so that they're open placeholders.
//
// This is because of the following scenario:
//
// class B<T>
// {
// class C<U>
// {
// }
// class D
// {
// void Foo()
// {
// Type T = typeof(C<>);
// }
// }
// }
//
// The outer type will be B<T>, but the inner type will be C<>. However,
// this will eventually be represented in IL as B<>.C<>. As such, we should
// keep our data structures clear - if we have one open type argument, then
// all of them must be open type arguments.
//
// Ensure that invariant here.
TypeArray pCheckedOuterTypeArgs = outerTypeArgs;
TypeManager pTypeManager = getAggregate().GetTypeManager();
if (_pTypeArgsThis.Count > 0 && AreAllTypeArgumentsUnitTypes(_pTypeArgsThis))
{
if (outerTypeArgs.Count > 0 && !AreAllTypeArgumentsUnitTypes(outerTypeArgs))
{
// We have open placeholder types in our type, but not the parent.
pCheckedOuterTypeArgs = pTypeManager.CreateArrayOfUnitTypes(outerTypeArgs.Count);
}
}
_pTypeArgsAll = pTypeManager.ConcatenateTypeArrays(pCheckedOuterTypeArgs, _pTypeArgsThis);
}