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); }