public MemberMetadataInfo GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code)
{
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 GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code)
{
return(GetTypeFromDefinition(handle));
}
public virtual string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code = SignatureTypeHandleCode.Unresolved)
{
TypeReference reference = reader.GetTypeReference(handle);
Handle scope = reference.ResolutionScope;
string name = reference.Namespace.IsNil
? reader.GetString(reference.Name)
: reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name);
switch (scope.Kind)
{
case HandleKind.ModuleReference:
return("[.module " + reader.GetString(reader.GetModuleReference((ModuleReferenceHandle)scope).Name) + "]" + name);
case HandleKind.AssemblyReference:
var assemblyReferenceHandle = (AssemblyReferenceHandle)scope;
var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return("[" + reader.GetString(assemblyReference.Name) + "]" + name);
case HandleKind.TypeReference:
return(GetTypeFromReference(reader, (TypeReferenceHandle)scope, code) + "/" + name);
default:
// rare cases: ModuleDefinition means search within defs of current module (used by WinMDs for projections)
// nil means search exported types of same module (haven't seen this in practice). For the test
// purposes here, it's sufficient to format both like defs.
Debug.Assert(scope == Handle.ModuleDefinition || scope.IsNil);
return(name);
}
}
private TType DecodeTypeHandle(ref BlobReader blobReader, SignatureTypeHandleCode code, bool allowTypeSpecifications)
{
// Force no differentiation of class vs. value type unless the option is enabled.
// Avoids cost of WinRT projection.
if ((_options & SignatureDecoderOptions.DifferentiateClassAndValueTypes) == 0)
{
code = SignatureTypeHandleCode.Unresolved;
}
EntityHandle handle = blobReader.ReadTypeHandle();
if (!handle.IsNil)
{
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
var typeDef = (TypeDefinitionHandle)handle;
return(_provider.GetTypeFromDefinition(_metadataReaderOpt, typeDef, code));
case HandleKind.TypeReference:
var typeRef = (TypeReferenceHandle)handle;
if (code != SignatureTypeHandleCode.Unresolved)
{
ProjectClassOrValueType(typeRef, ref code);
}
return(_provider.GetTypeFromReference(_metadataReaderOpt, typeRef, code));
case HandleKind.TypeSpecification:
if (!allowTypeSpecifications)
{
#if SRM
// To prevent cycles, the token following (CLASS | VALUETYPE) must not be a type spec.
// https://github.com/dotnet/coreclr/blob/8ff2389204d7c41b17eff0e9536267aea8d6496f/src/md/compiler/mdvalidator.cpp#L6154-L6160
throw new BadImageFormatException(SR.NotTypeDefOrRefHandle);
#else
throw new BadImageFormatException();
#endif
}
if (code != SignatureTypeHandleCode.Unresolved)
{
// TODO: We need more work here in differentiating case because instantiations can project class
// to value type as in IReference<T> -> Nullable<T>. Unblocking Roslyn work where the differentiation
// feature is not used. Note that the use-case of custom-mods will not hit this because there is no
// CLASS | VALUETYPE before the modifier token and so it always comes in unresolved.
code = SignatureTypeHandleCode.Unresolved; // never lie in the meantime.
}
var typeSpec = (TypeSpecificationHandle)handle;
return(_provider.GetTypeFromSpecification(_metadataReaderOpt, typeSpec, SignatureTypeHandleCode.Unresolved));
default:
// indicates an error returned from ReadTypeHandle, otherwise unreachable.
Debug.Assert(handle.IsNil); // will fall through to throw in release.
break;
}
}
#if SRM
throw new BadImageFormatException(SR.NotTypeDefOrRefOrSpecHandle);
#else
throw new BadImageFormatException();
#endif
}
public override string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
return(GetTypeFromHandle(reader, handle));
}
public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
return(string.Empty);
}
public TypeDesc GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
Debug.Assert(reader == _module.MetadataReader);
return(_module.GetType(handle));
}
public CilType GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code)
{
return(Reader.GetTypeSpecification(handle).DecodeSignature(this));
}
public override string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code)
{
return GetTypeFromHandle(reader, handle);
}
public override string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
return GetTypeFromHandle(reader, handle);
}
IrisType ITypeProvider <IrisType> .GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code)
{
TypeSpecification typeSpec = _reader.GetTypeSpecification(handle);
return(typeSpec.DecodeSignature(this));
}
IrisType ITypeProvider <IrisType> .GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
// We shouldn't be referencing any non-primitive types.
return(IrisType.Invalid);
}
IrisType ITypeProvider <IrisType> .GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code)
{
// Iris doesn't define any types that can be referenced.
return(IrisType.Invalid);
}
public MemberMetadataInfo GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
return(GetFullName(handle));
}
public TypeDesc GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code)
{
Debug.Assert(reader == _module.MetadataReader);
return(_module.GetType(handle));
}
public CilType GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code)
{
bool _isValueType = (code == SignatureTypeHandleCode.Class);
bool _isClass = (code == SignatureTypeHandleCode.ValueType);
CilType type = new CilType(GetFullName(Reader.GetTypeReference(handle)), _isValueType, _isClass);
return(type);
}
public virtual string GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, SignatureTypeHandleCode code = SignatureTypeHandleCode.Unresolved)
{
return(reader.GetTypeSpecification(handle).DecodeSignature(this));
}
public override string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code)
{
return(GetTypeFromHandle(reader, handle));
}
public virtual string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code = SignatureTypeHandleCode.Unresolved)
{
TypeDefinition definition = reader.GetTypeDefinition(handle);
string name = definition.Namespace.IsNil
? reader.GetString(definition.Name)
: reader.GetString(definition.Namespace) + "." + reader.GetString(definition.Name);
if (definition.Attributes.IsNested())
{
TypeDefinitionHandle declaringTypeHandle = definition.GetDeclaringType();
return(GetTypeFromDefinition(reader, declaringTypeHandle, SignatureTypeHandleCode.Unresolved) + "/" + name);
}
return(name);
}
private TType DecodeTypeDefOrRefOrSpec(ref BlobReader blobReader, SignatureTypeHandleCode code)
{
return(DecodeTypeHandle(ref blobReader, code, alllowTypeSpecifications: true));
}
public string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code)
{
return(string.Empty);
}
