private void ProjectClassOrValueType(TypeReferenceHandle handle, ref SignatureTypeHandleCode code)
{
Debug.Assert(code != SignatureTypeHandleCode.Unresolved);
Debug.Assert((_options & SignatureDecoderOptions.DifferentiateClassAndValueTypes) != 0);
if (_metadataReaderOpt == null)
{
// If we're asked to differentiate value types without a reader, then
// return the designation unprojected as it occurs in the signature blob.
return;
}
TypeReference typeRef = _metadataReaderOpt.GetTypeReference(handle);
switch (typeRef.SignatureTreatment)
{
case TypeRefSignatureTreatment.ProjectedToClass:
code = SignatureTypeHandleCode.Class;
break;
case TypeRefSignatureTreatment.ProjectedToValueType:
code = SignatureTypeHandleCode.ValueType;
break;
}
}
public virtual string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind = 0)
{
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) + "/" + 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);
}
}
public static EasyCustomAttribute?Read(MetadataReader reader, CustomAttribute attribute)
{
if (attribute.Constructor.Kind != HandleKind.MemberReference)
{
return(null);
}
var constructor = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor);
var typeReference = reader.GetTypeReference((TypeReferenceHandle)constructor.Parent);
var typeName = reader.GetString(typeReference.Namespace) + "." + reader.GetString(typeReference.Name);
// var resolutionScope = typeReference.ResolutionScope;
// if (resolutionScope.Kind == HandleKind.AssemblyReference)
// {
// var assemblyReference = reader.GetAssemblyReference((AssemblyReferenceHandle) resolutionScope);
// typeName += ", " + assemblyReference.GetSafeAssemblyName();
// }
CustomAttributeValue <object>?value = null;
try
{
value = attribute.DecodeValue(new AssemblyInfo.DummyProvider());
}
catch (Exception)
{
// ignored
}
return(new EasyCustomAttribute(typeName)
{
Value = value
});
}
public MethodInfo(AssemblyInfo assembly, MethodDefinitionHandle methodDefHandle, int token, SourceFile source, TypeInfo type, MetadataReader asmMetadataReader, MetadataReader pdbMetadataReader)
{
this.IsAsync = -1;
this.Assembly = assembly;
this.methodDef = asmMetadataReader.GetMethodDefinition(methodDefHandle);
this.DebugInformation = pdbMetadataReader.GetMethodDebugInformation(methodDefHandle.ToDebugInformationHandle());
this.source = source;
this.Token = token;
this.methodDefHandle = methodDefHandle;
this.Name = asmMetadataReader.GetString(methodDef.Name);
this.pdbMetadataReader = pdbMetadataReader;
this.IsEnCMethod = false;
this.TypeInfo = type;
if (!DebugInformation.SequencePointsBlob.IsNil)
{
var sps = DebugInformation.GetSequencePoints();
SequencePoint start = sps.First();
SequencePoint end = sps.First();
foreach (SequencePoint sp in sps)
{
if (sp.StartLine < start.StartLine)
{
start = sp;
}
else if (sp.StartLine == start.StartLine && sp.StartColumn < start.StartColumn)
{
start = sp;
}
if (sp.EndLine > end.EndLine)
{
end = sp;
}
else if (sp.EndLine == end.EndLine && sp.EndColumn > end.EndColumn)
{
end = sp;
}
}
StartLocation = new SourceLocation(this, start);
EndLocation = new SourceLocation(this, end);
foreach (var cattr in methodDef.GetCustomAttributes())
{
var ctorHandle = asmMetadataReader.GetCustomAttribute(cattr).Constructor;
if (ctorHandle.Kind == HandleKind.MemberReference)
{
var container = asmMetadataReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
var name = asmMetadataReader.GetString(asmMetadataReader.GetTypeReference((TypeReferenceHandle)container).Name);
if (name == "DebuggerHiddenAttribute")
{
this.IsHiddenFromDebugger = true;
break;
}
}
}
}
localScopes = pdbMetadataReader.GetLocalScopes(methodDefHandle);
}
// Doesn't handle nested types.
public static string?GetQualifiedTypeName(this MetadataReader reader, EntityHandle typeDefOrRef)
{
string?qualifiedName;
if (typeDefOrRef.Kind == HandleKind.TypeDefinition)
{
var typeDef = reader.GetTypeDefinition((TypeDefinitionHandle)typeDefOrRef);
if (typeDef.Namespace.IsNil)
{
return(reader.GetString(typeDef.Name));
}
else
{
return(reader.GetString(typeDef.Namespace) + "." + reader.GetString(typeDef.Name));
}
}
else if (typeDefOrRef.Kind == HandleKind.TypeReference)
{
var typeRef = reader.GetTypeReference((TypeReferenceHandle)typeDefOrRef);
if (typeRef.Namespace.IsNil)
{
return(reader.GetString(typeRef.Name));
}
else
{
return(reader.GetString(typeRef.Namespace) + "." + reader.GetString(typeRef.Name));
}
}
else
{
qualifiedName = null;
}
return(qualifiedName);
}
private void AddTypeReferenceNameParts(TypeReferenceHandle handle, List <string> simpleNames)
{
var typeReference = _metadataReader.GetTypeReference(handle);
AddNamespaceParts(typeReference.Namespace, simpleNames);
simpleNames.Add(GetMetadataNameWithoutBackticks(_metadataReader, typeReference.Name));
}
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 static bool CompareTypeReferenceToDefinition(TypeReferenceHandle tr1, MetadataReader mr1, TypeDefinitionHandle td2, MetadataReader mr2)
{
// TODO! The correct implementation here is probably to call into the assembly binder, but that's not available due to layering.
// For now, just implement comparison, which will be equivalent in all cases until we support loading multiple copies of the same assembly
TypeReference trData1 = mr1.GetTypeReference(tr1);
TypeDefinition tdData2 = mr2.GetTypeDefinition(td2);
if (!trData1.TypeName.StringEquals(tdData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
switch (trData1.ParentNamespaceOrType.HandleType)
{
case HandleType.TypeReference:
if (tdData2.EnclosingType.IsNull(mr2))
{
return(false);
}
return(CompareTypeReferenceToDefinition(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, tdData2.EnclosingType, mr2));
case HandleType.NamespaceReference:
return(CompareNamespaceReferenceToDefinition(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, tdData2.NamespaceDefinition, mr2));
default:
Debug.Assert(false);
throw new BadImageFormatException();
}
}
private Object ResolveTypeReference(TypeReferenceHandle handle)
{
TypeReference typeReference = _metadataReader.GetTypeReference(handle);
Object resolutionScope = GetObject(typeReference.ResolutionScope);
if (resolutionScope is ModuleDesc)
{
return(((ModuleDesc)(resolutionScope)).GetType(_metadataReader.GetString(typeReference.Namespace), _metadataReader.GetString(typeReference.Name)));
}
else
if (resolutionScope is MetadataType)
{
string typeName = _metadataReader.GetString(typeReference.Name);
if (!typeReference.Namespace.IsNil)
{
typeName = _metadataReader.GetString(typeReference.Namespace) + "." + typeName;
}
MetadataType result = ((MetadataType)(resolutionScope)).GetNestedType(typeName);
if (result != null)
{
return(result);
}
ThrowHelper.ThrowTypeLoadException(typeName, ((MetadataType)resolutionScope).Module);
}
// TODO
throw new NotImplementedException();
}
private static bool QualifiedNameEquals(MetadataReader reader, CustomAttribute attribute, string namespaceName, string typeName)
{
bool qualifiedNameEquals(StringHandle nameHandle, StringHandle namespaceHandle)
=> reader.StringComparer.Equals(nameHandle, typeName) && reader.StringComparer.Equals(namespaceHandle, namespaceName);
var ctorHandle = attribute.Constructor;
switch (ctorHandle.Kind)
{
case HandleKind.MemberReference:
var container = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
switch (container.Kind)
{
case HandleKind.TypeReference:
var containerRef = reader.GetTypeReference((TypeReferenceHandle)container);
return(qualifiedNameEquals(containerRef.Name, containerRef.Namespace));
case HandleKind.TypeDefinition:
var containerDef = reader.GetTypeDefinition((TypeDefinitionHandle)container);
return(qualifiedNameEquals(containerDef.Name, containerDef.Namespace));
default:
return(false);
}
case HandleKind.MethodDefinition:
var typeDef = reader.GetTypeDefinition(reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle).GetDeclaringType());
return(qualifiedNameEquals(typeDef.Name, typeDef.Namespace));
default:
return(false);
}
}
private static bool IsAttributeType(MetadataReader reader, CustomAttribute attribute, string targetNamespace, string targetName)
{
StringHandle namespaceMaybe;
StringHandle nameMaybe;
switch (attribute.Constructor.Kind)
{
case HandleKind.MemberReference:
MemberReference refConstructor = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor);
TypeReference refType = reader.GetTypeReference((TypeReferenceHandle)refConstructor.Parent);
namespaceMaybe = refType.Namespace;
nameMaybe = refType.Name;
break;
case HandleKind.MethodDefinition:
MethodDefinition defConstructor = reader.GetMethodDefinition((MethodDefinitionHandle)attribute.Constructor);
TypeDefinition defType = reader.GetTypeDefinition(defConstructor.GetDeclaringType());
namespaceMaybe = defType.Namespace;
nameMaybe = defType.Name;
break;
default:
Debug.Assert(false, "Unknown attribute constructor kind");
return(false);
}
return(reader.StringComparer.Equals(namespaceMaybe, targetNamespace) && reader.StringComparer.Equals(nameMaybe, targetName));
}
public ParameterTypeInfo GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
var type = reader.GetTypeReference(handle);
var name = reader.GetString(type.Name);
return(new ParameterTypeInfo(name, isComplex: false));
}
public MrType GetTypeFromReference(MetadataReader reader, TypeReferenceHandle referenceHandle)
{
var typeReference = reader.GetTypeReference(referenceHandle);
var scopeEntityHandle = typeReference.ResolutionScope;
string name = typeReference.Namespace.IsNil
? reader.GetString(typeReference.Name)
: reader.GetString(typeReference.Namespace) + "." + reader.GetString(typeReference.Name);
switch (scopeEntityHandle.Kind)
{
case HandleKind.AssemblyReference:
{
var assemblyReferenceHandle = (AssemblyReferenceHandle)scopeEntityHandle;
var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return(GetTypeFromAssembly(name, reader.GetString(assemblyReference.Name)));
}
case HandleKind.ModuleDefinition:
{
return(GetType(name));
}
case HandleKind.TypeReference:
{
// Todo: is there a way to get the assembly being referenced? Or is it always the same one?
TryFindMrType(name, reader, out var mrType);
return(mrType);
}
default:
throw new NotSupportedException();
}
}
private void Walk(TypeDefinition typeDefinition)
{
var baseTypeHandle = typeDefinition.BaseType;
if (baseTypeHandle.IsNil)
{
return;
}
var handleType = baseTypeHandle.HandleType;
if (handleType == HandleType.Type)
{
typeDefinition = metadataReader.GetTypeDefinition((TypeHandle)baseTypeHandle);
var typeFullName = metadataReader.GetFullTypeName(typeDefinition);
if (knownExportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownExportAttributeOrDerivedType.Add(typeFullName);
//isExportAttributeCache[baseTypeHandle] = ExportOrInheritedExport.Export;
return;
}
else if (knownImportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownImportAttributeOrDerivedType.Add(typeFullName);
//isImportAttributeCache[baseTypeHandle] = true;
return;
}
Walk(typeDefinition);
}
else if (handleType == HandleType.TypeReference)
{
TypeReference typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)baseTypeHandle);
var typeFullName = metadataReader.GetFullTypeName(typeReference);
if (knownExportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownExportAttributeOrDerivedType.Add(typeFullName);
//isExportAttributeCache[baseTypeHandle] = ExportOrInheritedExport.Export;
return;
}
else if (knownImportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownImportAttributeOrDerivedType.Add(typeFullName);
//isImportAttributeCache[baseTypeHandle] = true;
return;
}
}
else if (handleType == HandleType.TypeSpecification)
{
// TODO: not implemented
}
else
{
throw new NotImplementedException();
}
}
private TypeSignature DecodeTypeReference(
TypeReferenceHandle handle,
ImmutableArray <TypeSignature> typeArguments,
ref int typeArgumentOffset)
{
var typeRef = _reader.GetTypeReference(handle);
TypeSignature qualifier;
var scope = typeRef.ResolutionScope;
switch (scope.Kind)
{
case HandleKind.AssemblyReference:
case HandleKind.ModuleReference:
// Include namespace.
qualifier = GetNamespace(typeRef.Namespace);
break;
case HandleKind.TypeReference:
// Include declaring type.
qualifier = DecodeTypeReference((TypeReferenceHandle)scope, typeArguments, ref typeArgumentOffset);
break;
default:
throw new BadImageFormatException();
}
return(CreateTypeSignature(qualifier, _reader.GetString(typeRef.Name), typeArguments, ref typeArgumentOffset));
}
private DefType ResolveTypeReference(TypeReferenceHandle handle)
{
TypeReference typeReference = _metadataReader.GetTypeReference(handle);
if (typeReference.ParentNamespaceOrType.HandleType == HandleType.TypeReference)
{
// Nested type case
MetadataType containingType = (MetadataType)ResolveTypeReference(typeReference.ParentNamespaceOrType.ToTypeReferenceHandle(_metadataReader));
return(containingType.GetNestedType(_metadataReader.GetString(typeReference.TypeName)));
}
else
{
// Cross-assembly reference
// Get remote module, and then lookup by namespace/name
ScopeReferenceHandle scopeReferenceHandle = default(ScopeReferenceHandle);
NamespaceReferenceHandle initialNamespaceReferenceHandle = typeReference.ParentNamespaceOrType.ToNamespaceReferenceHandle(_metadataReader);
NamespaceReferenceHandle namespaceReferenceHandle = initialNamespaceReferenceHandle;
do
{
NamespaceReference namespaceReference = _metadataReader.GetNamespaceReference(namespaceReferenceHandle);
if (namespaceReference.ParentScopeOrNamespace.HandleType == HandleType.ScopeReference)
{
scopeReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToScopeReferenceHandle(_metadataReader);
}
else
{
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(_metadataReader);
}
} while (scopeReferenceHandle.IsNull(_metadataReader));
ModuleDesc remoteModule = GetModule(scopeReferenceHandle);
string namespaceName = _metadataReader.GetNamespaceName(initialNamespaceReferenceHandle);
string typeName = _metadataReader.GetString(typeReference.TypeName);
MetadataType resolvedType = remoteModule.GetType(namespaceName, typeName, throwIfNotFound: false);
if (resolvedType != null)
{
return(resolvedType);
}
// Special handling for the magic __Canon types cannot be currently put into
// NativeFormatModule because GetType returns a MetadataType.
if (remoteModule == _context.SystemModule)
{
string qualifiedTypeName = namespaceName + "." + typeName;
if (qualifiedTypeName == CanonType.FullName)
{
return(_context.CanonType);
}
if (qualifiedTypeName == UniversalCanonType.FullName)
{
return(_context.UniversalCanonType);
}
}
throw new NotImplementedException();
}
}
public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
var typeRef = reader.GetTypeReference(handle);
var name = reader.GetString(typeRef.Name);
return(typeRef.Namespace.IsNil ? name : reader.GetString(typeRef.Namespace) + "." + name);
}
public void GetTypeRefProps(
int typeReference,
out int resolutionScope,
[MarshalAs(UnmanagedType.LPWStr), Out] StringBuilder qualifiedName,
int qualifiedNameBufferLength,
out int qualifiedNameLength)
{
var handle = (TypeReferenceHandle)MetadataTokens.Handle(typeReference);
var typeRef = MetadataReader.GetTypeReference(handle);
if (qualifiedName != null)
{
qualifiedName.Clear();
if (!typeRef.Namespace.IsNil)
{
qualifiedName.Append(MetadataReader.GetString(typeRef.Namespace));
qualifiedName.Append('.');
}
qualifiedName.Append(MetadataReader.GetString(typeRef.Name));
qualifiedName.Length = qualifiedNameLength = Math.Min(qualifiedName.Length, Math.Max(0, qualifiedNameBufferLength - 1));
}
else
{
qualifiedNameLength =
(typeRef.Namespace.IsNil ? 0 : MetadataReader.GetString(typeRef.Namespace).Length + 1) +
MetadataReader.GetString(typeRef.Name).Length;
}
resolutionScope = MetadataTokens.GetToken(typeRef.ResolutionScope);
}
/// <summary>Gets the name of an attribute.</summary>
/// <param name="reader">The metadata reader.</param>
/// <param name="attr">The attribute.</param>
/// <param name="typeNamespaceHandle">The namespace of the attribute.</param>
/// <param name="typeNameHandle">The name of the attribute.</param>
/// <returns>true if the name could be retrieved; otherwise, false.</returns>
private static bool TryGetAttributeName(MetadataReader reader, CustomAttribute attr, out StringHandle typeNamespaceHandle, out StringHandle typeNameHandle)
{
EntityHandle ctorHandle = attr.Constructor;
switch (ctorHandle.Kind)
{
case HandleKind.MemberReference:
EntityHandle container = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
if (container.Kind == HandleKind.TypeReference)
{
TypeReference tr = reader.GetTypeReference((TypeReferenceHandle)container);
typeNamespaceHandle = tr.Namespace;
typeNameHandle = tr.Name;
return(true);
}
break;
case HandleKind.MethodDefinition:
MethodDefinition md = reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle);
TypeDefinition td = reader.GetTypeDefinition(md.GetDeclaringType());
typeNamespaceHandle = td.Namespace;
typeNameHandle = td.Name;
return(true);
}
// Unusual case, potentially invalid IL
typeNamespaceHandle = default(StringHandle);
typeNameHandle = default(StringHandle);
return(false);
}
/// <summary>
/// Given a type handle and a raw type kind found in a signature blob determines whether the target type is a value type or a reference type.
/// </summary>
public static SignatureTypeKind ResolveSignatureTypeKind(this MetadataReader reader, EntityHandle typeHandle, byte rawTypeKind)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var typeKind = (SignatureTypeKind)rawTypeKind;
switch (typeKind)
{
case SignatureTypeKind.Unknown:
return(SignatureTypeKind.Unknown);
case SignatureTypeKind.Class:
case SignatureTypeKind.ValueType:
break;
default:
// If read from metadata by the decoder the value would have been checked already.
// So it is the callers error to pass in an invalid value, not bad metadata.
throw new ArgumentOutOfRangeException(nameof(rawTypeKind));
}
switch (typeHandle.Kind)
{
case HandleKind.TypeDefinition:
// WinRT projections don't apply to TypeDefs
return(typeKind);
case HandleKind.TypeReference:
var treatment = reader.GetTypeReference((TypeReferenceHandle)typeHandle).SignatureTreatment;
switch (treatment)
{
case TypeRefSignatureTreatment.ProjectedToClass:
return(SignatureTypeKind.Class);
case TypeRefSignatureTreatment.ProjectedToValueType:
return(SignatureTypeKind.ValueType);
case TypeRefSignatureTreatment.None:
return(typeKind);
default:
throw ExceptionUtilities.UnexpectedValue(treatment);
}
case HandleKind.TypeSpecification:
// TODO: https://github.com/dotnet/corefx/issues/8139
// 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.
return(SignatureTypeKind.Unknown);
default:
throw new ArgumentOutOfRangeException(nameof(typeHandle), SR.UnexpectedHandleKind);
}
}
public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
var tr = reader.GetTypeReference(handle);
var name = reader.GetString(tr.Name);
// todo: scope
return(tr.Namespace.IsNil ? name : $"{reader.GetString (tr.Namespace)}.{name}");
}
public TypeRefEntry(PEFile module, TypeReferenceHandle handle)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.typeRef = metadata.GetTypeReference(handle);
}
public TypeSyntax GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
// CONSIDER: reuse GetNestingQualifiedName (with namespace support added) here.
var tr = reader.GetTypeReference(handle);
string name = reader.GetString(tr.Name);
string ns = reader.GetString(tr.Namespace);
return(ParseName(ns + "." + name));
}
private static void BuildFullName(EntityHandle handle, MetadataReader metadata, StringBuilder sb, out string assembly)
{
void BuildName(StringHandle stringHandle)
{
if (!stringHandle.IsNil)
{
if (sb.Length != 0)
{
sb.Append('.');
}
var value = metadata.GetString(stringHandle);
sb.Append(value);
}
}
switch (handle.Kind)
{
case HandleKind.MemberReference:
{
var memberReference = metadata.GetMemberReference((MemberReferenceHandle)handle);
BuildFullName(memberReference.Parent, metadata, sb, out assembly);
BuildName(memberReference.Name);
}
break;
case HandleKind.TypeReference:
{
var typeReference = metadata.GetTypeReference((TypeReferenceHandle)handle);
BuildFullName(typeReference.ResolutionScope, metadata, sb, out assembly);
BuildName(typeReference.Namespace);
BuildName(typeReference.Name);
}
break;
case HandleKind.AssemblyReference:
{
var assemblyReference = metadata.GetAssemblyReference((AssemblyReferenceHandle)handle);
assembly = metadata.GetString(assemblyReference.Name);
}
break;
case HandleKind.TypeDefinition:
{
var typeDefinition = metadata.GetTypeDefinition((TypeDefinitionHandle)handle);
BuildName(typeDefinition.Namespace);
BuildName(typeDefinition.Name);
// I think type definitions are always defined in the containing assembly.
// When it appears it should belong elsewhere, I think it's an embedded (COM?) type.
assembly = GetCurrentAssemblyName(metadata);
}
break;
default:
throw new NotImplementedException(handle.Kind.ToString());
}
}
// Original:
// Return $"typeref{RowId(handle)}";
public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind = 0)
{
var typeReference = reader.GetTypeReference(handle);
var @namespace = reader.GetString(typeReference.Name);
var name = reader.GetString(typeReference.Name);
return($"{@namespace}.{name}");
}
public static TypeKey GetTypeKey(this TypeReferenceHandle typeRef, MetadataReader reader)
{
if (typeRef.IsNil)
{
return(TypeKey.Undefined);
}
return(GetTypeKey(reader.GetTypeReference(typeRef), reader));
}
void ParseComponents()
{
foreach (var handle in metaReader.TypeDefinitions)
{
var typeDef = metaReader.GetTypeDefinition(handle);
var parentName = metaReader.GetString(typeDef.Name);
var baseTypeHandle = typeDef.BaseType;
// Work up to base reference (ie defined outside this assembly)
while (baseTypeHandle.Kind == HandleKind.TypeDefinition)
{
var baseTypeDef = metaReader.GetTypeDefinition((TypeDefinitionHandle)baseTypeHandle);
// No way to predetermine if .BaseType is valid
try
{
baseTypeHandle = baseTypeDef.BaseType;
}
catch (Exception) { break; }
}
if (baseTypeHandle.Kind == HandleKind.TypeReference)
{
var typeRef = metaReader.GetTypeReference((TypeReferenceHandle)baseTypeHandle);
var name = metaReader.GetString(typeRef.Name);
if (name != "CSComponent")
{
continue;
}
var inspector = new CSComponentInspector(typeDef, peFile, metaReader);
var icomponent = inspector.Inspect();
if (icomponent != null)
{
InspectorComponents[icomponent.Name] = icomponent;
}
}
}
}
public TypeMetadata GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
TypeReference typeRef = reader.GetTypeReference(handle);
if (!_metadataAnalyzer.TryLookupTypeReference(typeRef, out TypeMetadata typeMetadata))
{
throw new Exception($"Type not found in cache: '{reader.GetString(typeRef.Name)}'");
}
return(typeMetadata);
}
private void AddTypeReferenceNameParts(TypeReferenceHandle handle, List <string> simpleNames)
{
var typeReference = _metadataReader.GetTypeReference(handle);
var namespaceString = _metadataReader.GetString(typeReference.Namespace);
// NOTE(cyrusn): Unfortunately, we are forced to allocate here
// no matter what. The metadata reader API gives us no way to
// just get the component namespace parts for a namespace reference.
simpleNames.AddRange(namespaceString.Split(s_dotSeparator));
simpleNames.Add(GetMetadataNameWithoutBackticks(_metadataReader, typeReference.Name));
}
private static string DumpRec(this MetadataReader reader, EntityHandle handle)
{
switch (handle.Kind)
{
case HandleKind.AssemblyReference:
return(reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name));
case HandleKind.TypeDefinition:
{
TypeDefinition type = reader.GetTypeDefinition((TypeDefinitionHandle)handle);
return(getQualifiedName(type.Namespace, type.Name));
}
case HandleKind.MethodDefinition:
{
MethodDefinition method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
var blob = reader.GetBlobReader(method.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {DumpRec(reader, method.GetDeclaringType())}.{reader.GetString(method.Name)}({parameters})");
}
case HandleKind.MemberReference:
{
MemberReference member = reader.GetMemberReference((MemberReferenceHandle)handle);
var blob = reader.GetBlobReader(member.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {DumpRec(reader, member.Parent)}.{reader.GetString(member.Name)}({parameters})");
}
case HandleKind.TypeReference:
{
TypeReference type = reader.GetTypeReference((TypeReferenceHandle)handle);
return(getQualifiedName(type.Namespace, type.Name));
}
default:
return(null);
}
string getQualifiedName(StringHandle leftHandle, StringHandle rightHandle)
{
string name = reader.GetString(rightHandle);
if (!leftHandle.IsNil)
{
name = reader.GetString(leftHandle) + "." + name;
}
return(name);
}
}
public static bool CompareTypeReferenceAcrossModules(TypeReferenceHandle tr1, MetadataReader mr1, TypeReferenceHandle tr2, MetadataReader mr2)
{
TypeReference trData1 = mr1.GetTypeReference(tr1);
TypeReference trData2 = mr2.GetTypeReference(tr2);
if (!trData1.TypeName.StringEquals(trData2.TypeName.GetConstantStringValue(mr2).Value, mr1))
return false;
if (trData1.ParentNamespaceOrType.HandleType != trData2.ParentNamespaceOrType.HandleType)
return false;
if (trData1.ParentNamespaceOrType.HandleType == HandleType.TypeReference)
return CompareTypeReferenceAcrossModules(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, trData2.ParentNamespaceOrType.ToTypeReferenceHandle(mr2), mr2);
return CompareNamespaceReferenceAcrossModules(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, trData2.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr2), mr2);
}
public static bool CompareTypeReferenceToDefinition(TypeReferenceHandle tr1, MetadataReader mr1, TypeDefinitionHandle td2, MetadataReader mr2)
{
// TODO! The correct implementation here is probably to call into the assembly binder, but that's not available due to layering.
// For now, just implement comparison, which will be equivalent in all cases until we support loading multiple copies of the same assembly
TypeReference trData1 = mr1.GetTypeReference(tr1);
TypeDefinition tdData2 = mr2.GetTypeDefinition(td2);
if (!trData1.TypeName.StringEquals(tdData2.Name.GetConstantStringValue(mr2).Value, mr1))
return false;
switch (trData1.ParentNamespaceOrType.HandleType)
{
case HandleType.TypeReference:
if (tdData2.EnclosingType.IsNull(mr2))
return false;
return CompareTypeReferenceToDefinition(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, tdData2.EnclosingType, mr2);
case HandleType.NamespaceReference:
return CompareNamespaceReferenceToDefinition(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, tdData2.NamespaceDefinition, mr2);
default:
Debug.Assert(false);
throw new BadImageFormatException();
}
}
