private static Type EntityHandleToCatchType(MetadataReader reader, EntityHandle entityHandle) { StringHandle stringHandle; if (entityHandle.Kind == HandleKind.TypeDefinition) { stringHandle = reader.GetTypeDefinition((TypeDefinitionHandle)entityHandle).Name; } else if (entityHandle.Kind == HandleKind.TypeReference) { stringHandle = reader.GetTypeReference((TypeReferenceHandle)entityHandle).Name; } else if (entityHandle.Kind == HandleKind.TypeSpecification) { var decoded = reader.GetTypeSpecification((TypeSpecificationHandle)entityHandle).DecodeSignature(new DisassemblingTypeProvider()); //Console.WriteLine(decoded); return(Type.GetType(decoded)); } else { return(null); } return(Type.GetType(reader.GetString(stringHandle))); }
private static string GetMemberRef(MetadataReader metadataReader, int token, CilTypeProvider provider, string genericParameterSignature = "") { var refHandle = MetadataTokens.MemberReferenceHandle(token); var reference = metadataReader.GetMemberReference(refHandle); var parentToken = MetadataTokens.GetToken(reference.Parent); string type; if (IsTypeSpecification(parentToken)) { var typeSpecificationHandle = MetadataTokens.TypeSpecificationHandle(parentToken); var typeSpecification = metadataReader.GetTypeSpecification(typeSpecificationHandle); type = SignatureDecoder.DecodeType(typeSpecificationHandle, provider, null).ToString(); } else { var parentHandle = MetadataTokens.TypeReferenceHandle(parentToken); type = SignatureDecoder.DecodeType(parentHandle, provider, null).ToString(false); } string signatureValue; string parameters = string.Empty; if (reference.GetKind() == MemberReferenceKind.Method) { MethodSignature <CilType> signature = SignatureDecoder.DecodeMethodSignature(reference.Signature, provider); signatureValue = GetMethodReturnType(signature); parameters = provider.GetParameterList(signature); return(String.Format("{0} {1}::{2}{3}{4}", signatureValue, type, GetString(metadataReader, reference.Name), genericParameterSignature, parameters)); } signatureValue = SignatureDecoder.DecodeFieldSignature(reference.Signature, provider).ToString(); return(String.Format("{0} {1}::{2}{3}", signatureValue, type, GetString(metadataReader, reference.Name), parameters)); }
public DummyTypeInfo GetTypeFromSpecification(MetadataReader reader, ModuleTokenResolver genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { TypeSpecification typeSpec = reader.GetTypeSpecification(handle); typeSpec.DecodeSignature(this, genericContext); return(DummyTypeInfo.Instance); }
private string GetBaseTypeName(MetadataReader mdReader, TypeDefinition type) { EntityHandle baseTypeHandle = type.BaseType; if (baseTypeHandle.IsNil) { return(String.Empty); } HandleKind baseTypeHandleKind = baseTypeHandle.Kind; if (baseTypeHandleKind == HandleKind.TypeDefinition) { TypeDefinition baseType = mdReader.GetTypeDefinition((TypeDefinitionHandle)baseTypeHandle); return(mdReader.GetString(baseType.Namespace) + "." + mdReader.GetString(baseType.Name)); } else if (baseTypeHandleKind == HandleKind.TypeSpecification) { TypeSpecification baseType = mdReader.GetTypeSpecification((TypeSpecificationHandle)baseTypeHandle); // Don't have logic to convert signatures to names/strings // NOTE: Enums and Structs can't have user defined base types, so this shouldn't break distinguising enums/structs. return(String.Empty); } else if (baseTypeHandleKind == HandleKind.TypeReference) { TypeReference baseType = mdReader.GetTypeReference((TypeReferenceHandle)baseTypeHandle); return(mdReader.GetString(baseType.Namespace) + "." + mdReader.GetString(baseType.Name)); } return(String.Empty); }
/// <summary> /// Emit an arbitrary type specification. /// </summary> /// <param name="typeSpecHandle">Type specification handle</param> /// <param name="namespaceQualified">When set to true, include namespace information</param> private string EmitTypeSpecificationName(TypeSpecificationHandle typeSpecHandle, bool namespaceQualified) { TypeSpecification typeSpec = _metadataReader.GetTypeSpecification(typeSpecHandle); DisassemblingGenericContext genericContext = new DisassemblingGenericContext(Array.Empty <string>(), Array.Empty <string>()); return(typeSpec.DecodeSignature <string, DisassemblingGenericContext>(this, genericContext)); }
internal unsafe SharpLangType ResolveTypeHandle(ISharpLangGenericContext context, Handle handle) { switch (handle.Kind) { case HandleKind.TypeDefinition: return(ResolveTypeDef(null, (TypeDefinitionHandle)handle)); case HandleKind.TypeReference: { var typeReference = MetadataReader.GetTypeReference((TypeReferenceHandle)handle); var module = ResolveModule(typeReference.ResolutionScope); if (module == null) { throw new InvalidOperationException("Could not resolve module"); } return(module.ResolveType(MetadataReader.GetString(typeReference.Namespace), MetadataReader.GetString(typeReference.Name))); } case HandleKind.TypeSpecification: { var typeSpecification = MetadataReader.GetTypeSpecification((TypeSpecificationHandle)handle); var signatureReader = MetadataReader.GetBlobReader(typeSpecification.Signature); return(ReadSignature(context, signatureReader)); } case HandleKind.GenericParameter: default: throw new NotImplementedException(); } }
public IType ResolveType(EntityHandle typeRefDefSpec, GenericContext context, TypeSystemOptions customOptions, CustomAttributeHandleCollection?typeAttributes = null, Nullability nullableContext = Nullability.Oblivious) { if (typeRefDefSpec.IsNil) { return(SpecialType.UnknownType); } IType ty; switch (typeRefDefSpec.Kind) { case HandleKind.TypeDefinition: ty = TypeProvider.GetTypeFromDefinition(metadata, (TypeDefinitionHandle)typeRefDefSpec, 0); break; case HandleKind.TypeReference: ty = TypeProvider.GetTypeFromReference(metadata, (TypeReferenceHandle)typeRefDefSpec, 0); break; case HandleKind.TypeSpecification: var typeSpec = metadata.GetTypeSpecification((TypeSpecificationHandle)typeRefDefSpec); ty = typeSpec.DecodeSignature(TypeProvider, context); break; case HandleKind.ExportedType: return(ResolveForwardedType(metadata.GetExportedType((ExportedTypeHandle)typeRefDefSpec))); default: throw new BadImageFormatException("Not a type handle"); } ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, typeAttributes, metadata, customOptions, nullableContext); return(ty); }
public TypeSpecEntry(PEFile module, TypeSpecificationHandle handle) { this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset; this.module = module; this.metadata = module.Metadata; this.handle = handle; this.typeSpec = metadata.GetTypeSpecification(handle); }
// // Main routine to parse a metadata type specification signature. // private static RuntimeTypeInfo TryResolveTypeSignature(this TypeSpecificationHandle typeSpecHandle, MetadataReader reader, TypeContext typeContext, ref Exception exception) { TypeSpecification typeSpec = reader.GetTypeSpecification(typeSpecHandle); ReflectionTypeProvider refTypeProvider = new ReflectionTypeProvider(throwOnError: false); RuntimeTypeInfo result = typeSpec.DecodeSignature <RuntimeTypeInfo, TypeContext>(refTypeProvider, typeContext); exception = refTypeProvider.ExceptionResult; return(result); }
public EntityHandle GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle) { // Create a decoder to process the type specification (which happens with // instantiated generics). It will call back into us to get the first handle // for the type def or type ref that the specification starts with. var sigReader = reader.GetBlobReader(reader.GetTypeSpecification(handle).Signature); return(new SignatureDecoder <EntityHandle, object>(this, reader, genericContext: null).DecodeType(ref sigReader)); }
private Object ResolveTypeSpecification(TypeSpecificationHandle handle) { TypeSpecification typeSpecification = _metadataReader.GetTypeSpecification(handle); BlobReader signatureReader = _metadataReader.GetBlobReader(typeSpecification.Signature); EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader); return(parser.ParseType()); }
public static FullTypeName GetFullTypeName(this TypeSpecificationHandle handle, MetadataReader reader) { if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } var ts = reader.GetTypeSpecification(handle); return(ts.DecodeSignature(new Metadata.FullTypeNameSignatureDecoder(reader), default(Unit))); }
public MetadataType GetTypeFromSpecification( MetadataReader reader, GenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { return(reader .GetTypeSpecification(handle) .DecodeSignature(this, genericContext)); }
XSharpType ISignatureTypeProvider <XSharpType, object> .GetTypeFromSpecification( MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { TypeSpecification typeSpec = _reader.GetTypeSpecification(handle); return(typeSpec.DecodeSignature(this, genericContext)); }
public virtual string GetTypeFromHandle(MetadataReader reader, EntityHandle handle) { switch (handle.Kind) { case HandleKind.TypeDefinition: return(GetTypeFromDefinition(reader, (TypeDefinitionHandle)handle)); case HandleKind.TypeReference: return(GetTypeFromReference(reader, (TypeReferenceHandle)handle)); case HandleKind.TypeSpecification: return(reader.GetTypeSpecification((TypeSpecificationHandle)handle).DecodeSignature(this)); default: throw new ArgumentOutOfRangeException("handle"); } }
public MrType GetTypeFromEntityHandle(EntityHandle baseTypeEntityHandle, TypeDefinition typeDefinition) { var provider = new DisassemblingTypeProvider(this); switch (baseTypeEntityHandle.Kind) { case HandleKind.TypeDefinition: { var baseTypeDefinitionHandle = (TypeDefinitionHandle)baseTypeEntityHandle; //var baseTypeHandleWrapper = GetTypeFromEntityHandle(typeDefinition, baseTypeDefinitionHandle); var baseTypeHandleWrapper = MrType.CreateFromTypeDefinition(baseTypeDefinitionHandle, this); return(baseTypeHandleWrapper); } //case HandleKind.TypeDefinition: // type = GetTypeOfTypeDef((TypeDefinitionHandle)token, out isNoPiaLocalType, isContainingType: false); // break; case HandleKind.TypeSpecification: { var typeSpecification = Reader.GetTypeSpecification((TypeSpecificationHandle)baseTypeEntityHandle); var genericTypeParameters = typeDefinition .GetGenericParameters() .Select(h => MrType.CreateFromGenericParameterHandle(h, this)) .ToImmutableArray(); var context = new MRGenericContext(genericTypeParameters, ImmutableArray <MrType> .Empty); var mrType = typeSpecification.DecodeSignature(provider, context); return(mrType); } case HandleKind.TypeReference: { var referencedTypeDefinitionHandleWrapper = _loadContext.GetTypeFromReference(Reader, (TypeReferenceHandle)baseTypeEntityHandle); return(referencedTypeDefinitionHandleWrapper); } default: throw new Exception("Unknown entity type"); } }
private static MetadataTypeReference GetTypeFromEntityHandle(MetadataReader reader, TypeReferenceTypeProvider typeProvider, GenericContext genericContext, EntityHandle handle) { switch (handle.Kind) { case HandleKind.TypeReference: return(GetTypeFromTypeReferenceHandle(reader, (TypeReferenceHandle)handle)); case HandleKind.TypeDefinition: return(GetTypeFromTypeDefinitionHandle(reader, (TypeDefinitionHandle)handle)); case HandleKind.TypeSpecification: var baseTypeSpecification = reader.GetTypeSpecification((TypeSpecificationHandle)handle); return(baseTypeSpecification.DecodeSignature(typeProvider, genericContext)); default: throw new NotImplementedException(); } }
private Object ResolveTypeSpecification(TypeSpecificationHandle handle) { TypeSpecification typeSpecification = _metadataReader.GetTypeSpecification(handle); BlobReader signatureReader = _metadataReader.GetBlobReader(typeSpecification.Signature); EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure); TypeDesc parsedType = parser.ParseType(); if (parsedType == null) { return(parser.ResolutionFailure); } else { return(parsedType); } }
public MemberMetadataInfo GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, byte rawTypeKind) { var entityHandle = (EntityHandle)handle; switch (entityHandle.Kind) { case HandleKind.TypeDefinition: return(GetTypeFromDefinition((TypeDefinitionHandle)entityHandle)); case HandleKind.TypeReference: return(GetFullName((TypeReferenceHandle)entityHandle)); case HandleKind.TypeSpecification: var specification = reader.GetTypeSpecification((TypeSpecificationHandle)entityHandle); return(specification.DecodeSignature(this)); default: throw new NotSupportedException("This kind is not supported!"); } }
public MemberMetadataInfo GetTypeFromSpecification(MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { var entityHandle = (EntityHandle)handle; switch (entityHandle.Kind) { case HandleKind.TypeDefinition: return(GetTypeFromDefinition((TypeDefinitionHandle)entityHandle)); case HandleKind.TypeReference: return(GetFullName((TypeReferenceHandle)entityHandle)); case HandleKind.TypeSpecification: var specification = reader.GetTypeSpecification((TypeSpecificationHandle)entityHandle); return(specification.DecodeSignature(this, null)); default: throw new NotSupportedException(LocalizedStrings.UnsupportedKind); } }
/// <summary> /// Gets a collection of <see cref="TypeDescriptor"/>s for each implemented interface for the /// given <paramref name="type"/>. /// </summary> /// <param name="reader"> The extended <see cref="MetadataReader"/>. </param> /// <param name="type"> The type whose implemented interfaces should be returned. </param> /// <returns> A collection of <see cref="TypeDescriptor"/>s for each implemented interface. </returns> public static IEnumerable <TypeDescriptor> GetImplementedInterfaces(this MetadataReader reader, TypeDefinition type) { var interfaceImplementations = type.GetInterfaceImplementations(); if (interfaceImplementations.Count == 0) { return(Enumerable.Empty <TypeDescriptor>()); } var implementedInterfaces = new List <TypeDescriptor>(); foreach (var implementationHandle in interfaceImplementations) { var interfaceImplementation = reader.GetInterfaceImplementation(implementationHandle); // interface is declared in the same assembly as the type if (interfaceImplementation.Interface.Kind == HandleKind.TypeDefinition) { var definition = reader.GetTypeDefinition((TypeDefinitionHandle)interfaceImplementation.Interface); var @interface = reader.ToTypeDescriptor(definition); implementedInterfaces.Add(@interface); } // interface is declared in another assembly else if (interfaceImplementation.Interface.Kind == HandleKind.TypeReference) { var reference = reader.GetTypeReference((TypeReferenceHandle)interfaceImplementation.Interface); var @interface = reader.ToTypeDescriptor(reference); implementedInterfaces.Add(@interface); } // interface is generic if (interfaceImplementation.Interface.Kind == HandleKind.TypeSpecification) { var specification = reader.GetTypeSpecification((TypeSpecificationHandle)interfaceImplementation.Interface); var @interface = specification.DecodeSignature(new TypeDescriptorSignatureProvider(), null); implementedInterfaces.Add(@interface); } } return(implementedInterfaces); }
public MemberMetadataInfo GetModifiedType(MetadataReader reader, bool isRequired, EntityHandle modifierTypeHandle, MemberMetadataInfo unmodifiedType) { var builder = new StringBuilder(); builder.Append(isRequired ? "reqmod " : "optmod "); MemberMetadataInfo info = null; switch (modifierTypeHandle.Kind) { case HandleKind.TypeDefinition: info = GetTypeFromDefinition((TypeDefinitionHandle)modifierTypeHandle); builder.Append(info.ToString()); break; case HandleKind.TypeReference: info = GetTypeFromReference((TypeReferenceHandle)modifierTypeHandle); builder.Append(info.ToString()); break; case HandleKind.TypeSpecification: var specification = reader.GetTypeSpecification((TypeSpecificationHandle)modifierTypeHandle); var signature = specification.DecodeSignature(this); builder.Append(signature); break; default: throw new NotSupportedException("This kind is not supported!"); } unmodifiedType.Modifiers.Add(builder.ToString()); return(unmodifiedType); }
/// <summary> /// Emit an arbitrary type specification. /// </summary> /// <param name="typeSpecHandle">Type specification handle</param> /// <param name="namespaceQualified">When set to true, include namespace information</param> private void EmitTypeSpecificationName(TypeSpecificationHandle typeSpecHandle, bool namespaceQualified) { TypeSpecification typeSpec = _metadataReader.GetTypeSpecification(typeSpecHandle); EmitTypeName(typeSpec.Signature, namespaceQualified); }
ITypeSignature ISignatureTypeProvider <ITypeSignature, object> .GetTypeFromSpecification(MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { var ts = reader.GetTypeSpecification(handle); return(ts.DecodeSignature(this, genericContext)); }
public static string ToString(this MetadataReader reader, TypeSpecificationHandle x) => reader.ToString(reader.GetTypeSpecification(x));
private static string GetMemberRef(MetadataReader metadataReader, int token, CilTypeProvider provider, string genericParameterSignature = "") { var refHandle = MetadataTokens.MemberReferenceHandle(token); var reference = metadataReader.GetMemberReference(refHandle); var parentToken = MetadataTokens.GetToken(reference.Parent); string type; if (IsTypeSpecification(parentToken)) { var typeSpecificationHandle = MetadataTokens.TypeSpecificationHandle(parentToken); var typeSpecification = metadataReader.GetTypeSpecification(typeSpecificationHandle); type = SignatureDecoder.DecodeType(typeSpecificationHandle, provider, null).ToString(); } else { var parentHandle = MetadataTokens.TypeReferenceHandle(parentToken); type = SignatureDecoder.DecodeType(parentHandle, provider, null).ToString(false); } string signatureValue; string parameters = string.Empty; if (reference.GetKind() == MemberReferenceKind.Method) { MethodSignature<CilType> signature = SignatureDecoder.DecodeMethodSignature(reference.Signature, provider); signatureValue = GetMethodReturnType(signature); parameters = provider.GetParameterList(signature); return String.Format("{0} {1}::{2}{3}{4}", signatureValue, type, GetString(metadataReader, reference.Name), genericParameterSignature,parameters); } signatureValue = SignatureDecoder.DecodeFieldSignature(reference.Signature, provider).ToString(); return String.Format("{0} {1}::{2}{3}", signatureValue, type, GetString(metadataReader, reference.Name), parameters); }
public ParameterTypeInfo GetTypeFromSpecification(MetadataReader reader, object genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { var sigReader = reader.GetBlobReader(reader.GetTypeSpecification(handle).Signature); return(new SignatureDecoder <ParameterTypeInfo, object>(Instance, reader, genericContext).DecodeType(ref sigReader)); }
public virtual string GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code = SignatureTypeHandleCode.Unresolved) { return(reader.GetTypeSpecification(handle).DecodeSignature(this)); }
public FullTypeName GetTypeFromSpecification(MetadataReader reader, Unit genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { return(reader.GetTypeSpecification(handle).DecodeSignature(new FullTypeNameSignatureDecoder(metadata), default(Unit))); }
public virtual LocalVariable GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode rawTypeKind = 0) { return(reader.GetTypeSpecification(handle).DecodeSignature(this)); }
public virtual string GetTypeFromSpecification(MetadataReader reader, DisassemblingGenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind = 0) { return(reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext)); }