internal Type ResolveBaseType(SharpLangType context)
{
var typeDefinition = InternalModule.MetadataReader.GetTypeDefinition(InternalHandle);
var baseType = typeDefinition.BaseType;
if (baseType.IsNil)
return null;
return InternalModule.ResolveTypeHandle(context, baseType);
}
internal Type ResolveDeclaringType(SharpLangType context)
{
var typeDefinition = InternalModule.MetadataReader.GetTypeDefinition(InternalHandle);
var declaringType = typeDefinition.GetDeclaringType();
if (declaringType.IsNil)
{
return(null);
}
return(InternalModule.ResolveTypeHandle(context, declaringType));
}
internal Type ResolveBaseType(SharpLangType context)
{
var typeDefinition = InternalModule.MetadataReader.GetTypeDefinition(InternalHandle);
var baseType = typeDefinition.BaseType;
if (baseType.IsNil)
{
return(null);
}
return(InternalModule.ResolveTypeHandle(context, baseType));
}
unsafe protected SharpLangTypeElement(SharpLangEEType* eeType, SharpLangType elementType) : base(eeType)
{
this.elementType = elementType;
}
unsafe public SharpLangTypeGeneric(SharpLangEEType* eeType, SharpLangTypeDefinition definition, SharpLangType[] arguments) : base(eeType)
{
this.definition = definition;
this.arguments = arguments;
}
unsafe protected SharpLangTypeElement(SharpLangEEType *eeType, SharpLangType elementType) : base(eeType)
{
this.elementType = elementType;
}
public GenericKey(SharpLangType typeDefinition, SharpLangType[] genericArguments)
{
TypeDefinition = typeDefinition;
GenericArguments = genericArguments;
}
unsafe internal static SharpLangType ResolveType(SharpLangEEType *eeType)
{
// Check if already created
var cachedTypeField = eeType->CachedTypeField;
if (cachedTypeField != IntPtr.Zero)
{
return((SharpLangType)SharpLangHelper.GetObjectFromPointer((void *)cachedTypeField));
}
lock (SystemTypeLock)
{
// Check again inside the lock to avoid creation conflicts
cachedTypeField = eeType->CachedTypeField;
if (cachedTypeField != IntPtr.Zero)
{
return((SharpLangType)SharpLangHelper.GetObjectFromPointer((void *)cachedTypeField));
}
// Create SharpLangType
var kind = eeType->GetKind();
if (kind == SharpLangEEType.Kind.Array || kind == SharpLangEEType.Kind.Pointer || kind == SharpLangEEType.Kind.ByRef)
{
// Types with elements (ByRef, Pointer, Array)
var elementType = ResolveType((SharpLangEEType *)(eeType->ExtraTypeInfo - (int)kind));
return(ResolveElementType(eeType, elementType, kind));
}
var typeDef = &eeType->TypeDefinition;
if (kind == SharpLangEEType.Kind.TypeDef)
{
// Normal type definition
return(typeDef->Module.ResolveTypeDef(eeType, typeDef->Handle));
}
if (kind == SharpLangEEType.Kind.Generics)
{
// Find generic arguments
var genericVTable = (SharpLangEEType **)eeType->ExtraTypeInfo;
int genericVTableCount = 0;
// First count them
for (var genericVTableIt = genericVTable; *genericVTableIt != null; ++genericVTableIt)
{
genericVTableCount++;
}
// Then build the array
var genericArguments = new SharpLangType[genericVTableCount];
for (int i = 0; i < genericVTableCount; ++i)
{
genericArguments[i] = ResolveType(*genericVTable++);
}
// TODO: Build dependent types (generic type def + generic arguments) lazily could make initialization faster
return(ResolveGenericType(eeType, typeDef->Module.ResolveTypeDef(null, typeDef->Handle), genericArguments));
}
throw new InvalidOperationException(string.Format("Unknown type kind: {0}", kind));
}
}
internal unsafe static SharpLangTypeElement ResolveElementType(SharpLangEEType *eeType, SharpLangType elementType, SharpLangEEType.Kind kind)
{
Dictionary <SharpLangType, SharpLangTypeElement> elementTypes;
switch (kind)
{
case SharpLangEEType.Kind.Array:
elementTypes = arrayTypes;
break;
case SharpLangEEType.Kind.Pointer:
elementTypes = pointerTypes;
break;
case SharpLangEEType.Kind.ByRef:
elementTypes = byRefTypes;
break;
default:
throw new ArgumentOutOfRangeException();
}
lock (SystemTypeLock)
{
// Check if type has already been instantiated
SharpLangTypeElement sharpLangType;
if (elementTypes.TryGetValue(elementType, out sharpLangType))
{
return(sharpLangType);
}
if (eeType == null)
{
var sharpLangTypeSearchKey = new SharpLangEETypeComparer.SharpLangTypeSearchKey
{
Kind = kind,
ElementType = elementType,
};
var typeIndex = SharpLangEETypeComparer.BinarySearch(types, ref sharpLangTypeSearchKey);
if (typeIndex >= 0)
{
eeType = types[typeIndex];
}
}
switch (kind)
{
case SharpLangEEType.Kind.Array:
sharpLangType = new SharpLangTypeArray(eeType, elementType, 1);
break;
case SharpLangEEType.Kind.Pointer:
sharpLangType = new SharpLangTypePointer(eeType, elementType);
break;
case SharpLangEEType.Kind.ByRef:
sharpLangType = new SharpLangTypeByRef(eeType, elementType);
break;
default:
throw new ArgumentOutOfRangeException();
}
elementTypes.Add(elementType, sharpLangType);
if (eeType != null)
{
eeType->CachedTypeField = (IntPtr)SharpLangHelper.GetObjectPointer(sharpLangType);
}
return(sharpLangType);
}
}
unsafe internal SharpLangType ReadSignature(ISharpLangGenericContext context, BlobReader signatureReader)
{
var signatureTypeCode = signatureReader.ReadSignatureTypeCode();
switch (signatureTypeCode)
{
#region Primitive types
case SignatureTypeCode.Void:
return((SharpLangType)typeof(void));
case SignatureTypeCode.Boolean:
return((SharpLangType)typeof(bool));
case SignatureTypeCode.Char:
return((SharpLangType)typeof(char));
case SignatureTypeCode.Byte:
return((SharpLangType)typeof(byte));
case SignatureTypeCode.SByte:
return((SharpLangType)typeof(sbyte));
case SignatureTypeCode.UInt16:
return((SharpLangType)typeof(ushort));
case SignatureTypeCode.Int16:
return((SharpLangType)typeof(short));
case SignatureTypeCode.UInt32:
return((SharpLangType)typeof(uint));
case SignatureTypeCode.Int32:
return((SharpLangType)typeof(int));
case SignatureTypeCode.UInt64:
return((SharpLangType)typeof(ulong));
case SignatureTypeCode.Int64:
return((SharpLangType)typeof(long));
case SignatureTypeCode.Single:
return((SharpLangType)typeof(float));
case SignatureTypeCode.Double:
return((SharpLangType)typeof(double));
case SignatureTypeCode.UIntPtr:
return((SharpLangType)typeof(UIntPtr));
case SignatureTypeCode.IntPtr:
return((SharpLangType)typeof(IntPtr));
case SignatureTypeCode.Object:
return((SharpLangType)typeof(object));
case SignatureTypeCode.String:
return((SharpLangType)typeof(string));
case SignatureTypeCode.TypedReference:
return((SharpLangType)typeof(TypedReference));
#endregion
case SignatureTypeCode.TypeHandle:
return(ResolveTypeHandle(context, signatureReader.ReadTypeHandle()));
case SignatureTypeCode.Pointer:
return(ResolveElementType(null, ReadSignature(context, signatureReader), SharpLangEEType.Kind.Pointer));
case SignatureTypeCode.ByReference:
return(ResolveElementType(null, ReadSignature(context, signatureReader), SharpLangEEType.Kind.ByRef));
case SignatureTypeCode.SZArray:
return(ResolveElementType(null, ReadSignature(context, signatureReader), SharpLangEEType.Kind.Array));
case SignatureTypeCode.Array:
{
var elementType = ReadSignature(context, signatureReader);
// Read ArrayShape
var rank = signatureReader.ReadCompressedInteger();
var numSizes = signatureReader.ReadCompressedInteger();
for (int i = 0; i < numSizes; ++i)
{
signatureReader.ReadCompressedInteger();
}
var numLoBounds = signatureReader.ReadCompressedInteger();
for (int i = 0; i < numSizes; ++i)
{
signatureReader.ReadCompressedSignedInteger();
}
return(ResolveElementType(null, elementType, SharpLangEEType.Kind.Array));
}
case SignatureTypeCode.GenericTypeInstance:
{
var isValueType = signatureReader.ReadByte();
var genericTypeDefinition = (SharpLangTypeDefinition)ResolveTypeHandle(context, signatureReader.ReadTypeHandle());
var genericArgumentCount = signatureReader.ReadCompressedInteger();
var genericArguments = new SharpLangType[genericArgumentCount];
for (int i = 0; i < genericArgumentCount; ++i)
{
genericArguments[i] = ReadSignature(context, signatureReader);
}
return(ResolveGenericType(null, genericTypeDefinition, genericArguments));
}
case SignatureTypeCode.GenericTypeParameter:
{
if (context == null)
{
throw new InvalidOperationException();
}
var methodInfoContext = context as SharpLangMethodInfo;
if (methodInfoContext != null)
{
context = (SharpLangType)((SharpLangMethodInfo)context).DeclaringType;
}
var index = signatureReader.ReadCompressedInteger();
var typeDefinitionContext = context as SharpLangTypeDefinition;
if (typeDefinitionContext != null)
{
var genericParameters = typeDefinitionContext.InternalGetGenericParameters();
return(genericParameters[index]);
}
var typeGenericContext = context as SharpLangTypeGeneric;
if (typeGenericContext != null)
{
var genericArguments = typeGenericContext.InternalArguments;
return(genericArguments[index]);
}
// Not sure yet what other cases could happen here...
throw new NotSupportedException();
}
case SignatureTypeCode.GenericMethodParameter:
{
if (context == null)
{
throw new InvalidOperationException();
}
var index = signatureReader.ReadCompressedInteger();
var methodInfoContext = context as SharpLangMethodInfo;
if (methodInfoContext != null)
{
var genericParameters = methodInfoContext.InternalGetGenericParameters();
return(genericParameters[index]);
}
// Not sure yet what other cases could happen here...
throw new NotSupportedException();
}
case SignatureTypeCode.OptionalModifier:
case SignatureTypeCode.RequiredModifier:
case SignatureTypeCode.Pinned:
case SignatureTypeCode.Sentinel:
default:
throw new NotImplementedException();
}
}
internal Type ResolveDeclaringType(SharpLangType context)
{
var typeDefinition = InternalModule.MetadataReader.GetTypeDefinition(InternalHandle);
var declaringType = typeDefinition.GetDeclaringType();
if (declaringType.IsNil)
return null;
return InternalModule.ResolveTypeHandle(context, declaringType);
}
