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