public IType VisitArraySignature(ArraySignature arraySignature)
{
var underlyingType = ParseTypeSignature(_context, arraySignature.UnderlyingType);
return(underlyingType != null
? new ArrayType(underlyingType, arraySignature.Length)
: null);
}
public static string GetFullName(this ArraySignatureHandle handle, MetadataReader reader)
{
ArraySignature array = handle.GetArraySignature(reader);
var result = array.ElementType.GetFullName(reader);
if (result == null)
{
return(null);
}
return(result + "[" + (new string(',', array.Rank - 1)) + "]");
}
/// <summary>
/// Emit multi-dimensional array type.
/// </summary>
/// <param name="arraySigHandle">Multi-dimensional array type specification signature handle</param>
/// <param name="namespaceQualified">When set to true, include namespace information</param>
private void EmitArrayTypeName(ArraySignatureHandle arraySigHandle, bool namespaceQualified)
{
ArraySignature arraySig = _metadataReader.GetArraySignature(arraySigHandle);
EmitTypeName(arraySig.ElementType, namespaceQualified);
_outputBuilder.Append('[');
if (arraySig.Rank > 1)
{
_outputBuilder.Append(',', arraySig.Rank - 1);
}
else
{
_outputBuilder.Append('*');
}
_outputBuilder.Append(']');
}
//
// Main routine to parse a metadata type specification signature.
//
private static RuntimeTypeInfo?TryResolveTypeSignature(this TypeSpecificationHandle typeSpecHandle, MetadataReader reader, TypeContext typeContext, ref Exception?exception)
{
Handle typeHandle = typeSpecHandle.GetTypeSpecification(reader).Signature;
switch (typeHandle.HandleType)
{
case HandleType.ArraySignature:
{
ArraySignature sig = typeHandle.ToArraySignatureHandle(reader).GetArraySignature(reader);
int rank = sig.Rank;
if (rank <= 0)
{
throw new BadImageFormatException(); // Bad rank.
}
RuntimeTypeInfo?elementType = sig.ElementType.TryResolve(reader, typeContext, ref exception);
if (elementType == null)
{
return(null);
}
return(elementType.GetMultiDimArrayType(rank));
}
case HandleType.ByReferenceSignature:
{
ByReferenceSignature sig = typeHandle.ToByReferenceSignatureHandle(reader).GetByReferenceSignature(reader);
RuntimeTypeInfo? targetType = sig.Type.TryResolve(reader, typeContext, ref exception);
if (targetType == null)
{
return(null);
}
return(targetType.GetByRefType());
}
case HandleType.MethodTypeVariableSignature:
{
MethodTypeVariableSignature sig = typeHandle.ToMethodTypeVariableSignatureHandle(reader).GetMethodTypeVariableSignature(reader);
return(typeContext.GenericMethodArguments[sig.Number]);
}
case HandleType.PointerSignature:
{
PointerSignature sig = typeHandle.ToPointerSignatureHandle(reader).GetPointerSignature(reader);
RuntimeTypeInfo? targetType = sig.Type.TryResolve(reader, typeContext, ref exception);
if (targetType == null)
{
return(null);
}
return(targetType.GetPointerType());
}
case HandleType.SZArraySignature:
{
SZArraySignature sig = typeHandle.ToSZArraySignatureHandle(reader).GetSZArraySignature(reader);
RuntimeTypeInfo? elementType = sig.ElementType.TryResolve(reader, typeContext, ref exception);
if (elementType == null)
{
return(null);
}
return(elementType.GetArrayType());
}
case HandleType.TypeDefinition:
{
return(typeHandle.ToTypeDefinitionHandle(reader).ResolveTypeDefinition(reader));
}
case HandleType.TypeInstantiationSignature:
{
TypeInstantiationSignature sig = typeHandle.ToTypeInstantiationSignatureHandle(reader).GetTypeInstantiationSignature(reader);
RuntimeTypeInfo? genericTypeDefinition = sig.GenericType.TryResolve(reader, typeContext, ref exception);
if (genericTypeDefinition == null)
{
return(null);
}
LowLevelList <RuntimeTypeInfo> genericTypeArguments = new LowLevelList <RuntimeTypeInfo>();
foreach (Handle genericTypeArgumentHandle in sig.GenericTypeArguments)
{
RuntimeTypeInfo?genericTypeArgument = genericTypeArgumentHandle.TryResolve(reader, typeContext, ref exception);
if (genericTypeArgument == null)
{
return(null);
}
genericTypeArguments.Add(genericTypeArgument);
}
return(genericTypeDefinition.GetConstructedGenericType(genericTypeArguments.ToArray()));
}
case HandleType.TypeReference:
{
return(typeHandle.ToTypeReferenceHandle(reader).TryResolveTypeReference(reader, ref exception));
}
case HandleType.TypeVariableSignature:
{
TypeVariableSignature sig = typeHandle.ToTypeVariableSignatureHandle(reader).GetTypeVariableSignature(reader);
return(typeContext.GenericTypeArguments[sig.Number]);
}
default:
throw new NotSupportedException(); // Unexpected Type signature type.
}
}
private bool CompareTypeSigWithType(ref NativeParser parser, Handle typeHandle)
{
while (typeHandle.HandleType == HandleType.TypeSpecification)
{
typeHandle = typeHandle
.ToTypeSpecificationHandle(_metadataReader)
.GetTypeSpecification(_metadataReader)
.Signature;
}
// startOffset lets us backtrack to the TypeSignatureKind for external types since the TypeLoader
// expects to read it in.
uint startOffset = parser.Offset;
uint data;
var typeSignatureKind = parser.GetTypeSignatureKind(out data);
switch (typeSignatureKind)
{
case TypeSignatureKind.Lookback:
{
NativeParser lookbackParser = parser.GetLookbackParser(data);
return(CompareTypeSigWithType(ref lookbackParser, typeHandle));
}
case TypeSignatureKind.Modifier:
{
// Ensure the modifier kind (vector, pointer, byref) is the same
TypeModifierKind modifierKind = (TypeModifierKind)data;
switch (modifierKind)
{
case TypeModifierKind.Array:
if (typeHandle.HandleType == HandleType.SZArraySignature)
{
return(CompareTypeSigWithType(ref parser, typeHandle
.ToSZArraySignatureHandle(_metadataReader)
.GetSZArraySignature(_metadataReader)
.ElementType));
}
return(false);
case TypeModifierKind.ByRef:
if (typeHandle.HandleType == HandleType.ByReferenceSignature)
{
return(CompareTypeSigWithType(ref parser, typeHandle
.ToByReferenceSignatureHandle(_metadataReader)
.GetByReferenceSignature(_metadataReader)
.Type));
}
return(false);
case TypeModifierKind.Pointer:
if (typeHandle.HandleType == HandleType.PointerSignature)
{
return(CompareTypeSigWithType(ref parser, typeHandle
.ToPointerSignatureHandle(_metadataReader)
.GetPointerSignature(_metadataReader)
.Type));
}
return(false);
default:
Debug.Assert(null == "invalid type modifier kind");
return(false);
}
}
case TypeSignatureKind.Variable:
{
bool isMethodVar = (data & 0x1) == 1;
uint index = data >> 1;
if (isMethodVar)
{
if (typeHandle.HandleType == HandleType.MethodTypeVariableSignature)
{
return(index == typeHandle
.ToMethodTypeVariableSignatureHandle(_metadataReader)
.GetMethodTypeVariableSignature(_metadataReader)
.Number);
}
}
else
{
if (typeHandle.HandleType == HandleType.TypeVariableSignature)
{
return(index == typeHandle
.ToTypeVariableSignatureHandle(_metadataReader)
.GetTypeVariableSignature(_metadataReader)
.Number);
}
}
return(false);
}
case TypeSignatureKind.MultiDimArray:
{
if (typeHandle.HandleType != HandleType.ArraySignature)
{
return(false);
}
ArraySignature sig = typeHandle
.ToArraySignatureHandle(_metadataReader)
.GetArraySignature(_metadataReader);
if (data != sig.Rank)
{
return(false);
}
if (!CompareTypeSigWithType(ref parser, sig.ElementType))
{
return(false);
}
uint boundCount1 = parser.GetUnsigned();
for (uint i = 0; i < boundCount1; i++)
{
parser.GetUnsigned();
}
uint lowerBoundCount1 = parser.GetUnsigned();
for (uint i = 0; i < lowerBoundCount1; i++)
{
parser.GetUnsigned();
}
break;
}
case TypeSignatureKind.FunctionPointer:
{
// callingConvention is in data
uint argCount1 = parser.GetUnsigned();
for (uint i = 0; i < argCount1; i++)
{
if (!CompareTypeSigWithType(ref parser, typeHandle))
{
return(false);
}
}
return(false);
}
case TypeSignatureKind.Instantiation:
{
if (typeHandle.HandleType != HandleType.TypeInstantiationSignature)
{
return(false);
}
TypeInstantiationSignature sig = typeHandle
.ToTypeInstantiationSignatureHandle(_metadataReader)
.GetTypeInstantiationSignature(_metadataReader);
if (!CompareTypeSigWithType(ref parser, sig.GenericType))
{
return(false);
}
uint genericArgIndex = 0;
foreach (Handle genericArgumentTypeHandle in sig.GenericTypeArguments)
{
if (genericArgIndex >= data)
{
// The metadata generic has more parameters than the native layour
return(false);
}
if (!CompareTypeSigWithType(ref parser, genericArgumentTypeHandle))
{
return(false);
}
genericArgIndex++;
}
// Make sure all generic parameters have been matched
return(genericArgIndex == data);
}
case TypeSignatureKind.External:
{
RuntimeTypeHandle type2;
switch (typeHandle.HandleType)
{
case HandleType.TypeDefinition:
if (!TypeLoaderEnvironment.Instance.TryGetOrCreateNamedTypeForMetadata(
_metadataReader, typeHandle.ToTypeDefinitionHandle(_metadataReader), out type2))
{
return(false);
}
break;
case HandleType.TypeReference:
if (!TypeLoaderEnvironment.TryGetNamedTypeForTypeReference(
_metadataReader, typeHandle.ToTypeReferenceHandle(_metadataReader), out type2))
{
return(false);
}
break;
default:
return(false);
}
RuntimeTypeHandle type1 = SigParsing.GetTypeFromNativeLayoutSignature(ref parser, startOffset);
return(type1.Equals(type2));
}
default:
return(false);
}
return(true);
}
