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();
}
}
private Object ResolveAssemblyReference(ScopeReferenceHandle handle)
{
ScopeReference assemblyReference = _metadataReader.GetScopeReference(handle);
AssemblyName an = new AssemblyName();
an.Name = _metadataReader.GetString(assemblyReference.Name);
an.Version = new Version(assemblyReference.MajorVersion, assemblyReference.MinorVersion, assemblyReference.BuildNumber, assemblyReference.RevisionNumber);
an.CultureName = _metadataReader.GetString(assemblyReference.Culture) ?? "";
var publicKeyOrToken = assemblyReference.PublicKeyOrToken.ConvertByteCollectionToArray();
if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0)
{
an.SetPublicKey(publicKeyOrToken);
}
else
{
an.SetPublicKeyToken(publicKeyOrToken);
}
// TODO: ContentType - depends on newer version of the System.Reflection contract
return(Context.ResolveAssembly(an));
}
public static string GetFullName(this ScopeReferenceHandle scopeRefHandle, MetadataReader reader)
{
var scopeRef = scopeRefHandle.GetScopeReference(reader);
Debug.Assert(!scopeRef.Name.IsNull(reader));
var assemblyName = new AssemblyName
{
Name = scopeRef.Name.GetConstantStringValue(reader).Value,
CultureName = scopeRef.Culture.IsNull(reader) ? null : scopeRef.Culture.GetConstantStringValue(reader).Value,
Version = new Version(scopeRef.MajorVersion, scopeRef.MinorVersion, scopeRef.BuildNumber, scopeRef.RevisionNumber)
};
if (scopeRef.PublicKeyOrToken.Count > 0)
{
var pkt = new byte[scopeRef.PublicKeyOrToken.Count];
int index = 0;
foreach (var b in scopeRef.PublicKeyOrToken)
{
pkt[index++] = b;
}
assemblyName.SetPublicKeyToken(pkt);
}
else
{
assemblyName.SetPublicKeyToken(Array.Empty <byte>());
}
return(assemblyName.FullName);
}
} // Read
public static uint Read(this NativeReader reader, uint offset, out ScopeReferenceHandle handle)
{
uint value;
offset = reader.DecodeUnsigned(offset, out value);
handle = new ScopeReferenceHandle((int)value);
handle._Validate();
return(offset);
} // Read
public static RuntimeAssemblyName ToRuntimeAssemblyName(this ScopeReferenceHandle scopeReferenceHandle, MetadataReader reader)
{
ScopeReference scopeReference = scopeReferenceHandle.GetScopeReference(reader);
return(CreateRuntimeAssemblyNameFromMetadata(
reader,
scopeReference.Name,
scopeReference.MajorVersion,
scopeReference.MinorVersion,
scopeReference.BuildNumber,
scopeReference.RevisionNumber,
scopeReference.Culture,
scopeReference.PublicKeyOrToken,
scopeReference.Flags
));
}
private Exception TryResolveCaseInsensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result)
{
String fullName = this.ToString().ToLower();
LowLevelDictionary <String, QHandle> dict = GetCaseInsensitiveTypeDictionary(currentAssembly);
QHandle qualifiedHandle;
if (!dict.TryGetValue(fullName, out qualifiedHandle))
{
result = null;
return(new TypeLoadException(SR.Format(SR.TypeLoad_TypeNotFound, this.ToString(), currentAssembly.FullName)));
}
MetadataReader reader = qualifiedHandle.Reader;
Handle typeDefOrForwarderHandle = qualifiedHandle.Handle;
HandleType handleType = typeDefOrForwarderHandle.HandleType;
switch (handleType)
{
case HandleType.TypeDefinition:
{
TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader);
result = reflectionDomain.ResolveTypeDefinition(reader, typeDefinitionHandle);
return(null);
}
case HandleType.TypeForwarder:
{
TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader);
ScopeReferenceHandle destinationScope = typeForwarder.Scope;
RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader);
RuntimeAssembly destinationAssembly;
Exception exception = RuntimeAssembly.TryGetRuntimeAssembly(reflectionDomain, destinationAssemblyName, out destinationAssembly);
if (exception != null)
{
result = null;
return(exception);
}
return(TryResolveCaseInsensitive(reflectionDomain, destinationAssembly, out result));
}
default:
throw new InvalidOperationException();
}
}
internal sealed override RuntimeTypeInfo GetTypeCoreCaseInsensitive(string fullName)
{
LowLevelDictionary <string, QHandle> dict = CaseInsensitiveTypeDictionary;
QHandle qualifiedHandle;
if (!dict.TryGetValue(fullName.ToLowerInvariant(), out qualifiedHandle))
{
return(null);
}
MetadataReader reader = qualifiedHandle.Reader;
Handle typeDefOrForwarderHandle = qualifiedHandle.Handle;
HandleType handleType = typeDefOrForwarderHandle.HandleType;
switch (handleType)
{
case HandleType.TypeDefinition:
{
TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader);
return(typeDefinitionHandle.ResolveTypeDefinition(reader));
}
case HandleType.TypeForwarder:
{
TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader);
ScopeReferenceHandle destinationScope = typeForwarder.Scope;
RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader);
RuntimeAssemblyInfo destinationAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(destinationAssemblyName);
if (destinationAssembly == null)
{
return(null);
}
return(destinationAssembly.GetTypeCoreCaseInsensitive(fullName));
}
default:
throw new InvalidOperationException();
}
}
public static AssemblyQualifiedTypeName ToAssemblyQualifiedTypeName(this NamespaceReferenceHandle namespaceReferenceHandle, String typeName, MetadataReader reader)
{
LowLevelList <String> namespaceParts = new LowLevelList <String>(8);
NamespaceReference namespaceReference;
for (; ;)
{
namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
String namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break;
}
namespaceParts.Add(namespacePart);
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedNamespaceReferenceHandle(reader);
}
ScopeReferenceHandle scopeReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedScopeReferenceHandle(reader);
RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader);
return(new AssemblyQualifiedTypeName(new NamespaceTypeName(namespaceParts.ToArray(), typeName), assemblyName));
}
public static bool CompareScopeReferenceAcrossModules(ScopeReferenceHandle sr1, MetadataReader mr1, ScopeReferenceHandle sr2, MetadataReader mr2)
{
ScopeReference srData1 = mr1.GetScopeReference(sr1);
ScopeReference srData2 = mr2.GetScopeReference(sr2);
if (!srData1.Name.StringEquals(srData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (!srData1.Culture.StringEquals(srData2.Culture.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (srData1.MajorVersion != srData2.MajorVersion)
{
return(false);
}
if (srData1.MinorVersion != srData2.MinorVersion)
{
return(false);
}
if (srData1.RevisionNumber != srData2.RevisionNumber)
{
return(false);
}
if (srData1.BuildNumber != srData2.BuildNumber)
{
return(false);
}
return(ComparePublicKeyOrTokens(srData1.PublicKeyOrToken, srData1.Flags.HasFlag(AssemblyFlags.PublicKey), srData2.PublicKeyOrToken, srData2.Flags.HasFlag(AssemblyFlags.PublicKey)));
}
public static bool CompareScopeReferenceToDefinition(ScopeReferenceHandle sr1, MetadataReader mr1, ScopeDefinitionHandle sd2, MetadataReader mr2)
{
ScopeReference srData1 = mr1.GetScopeReference(sr1);
ScopeDefinition sdData2 = mr2.GetScopeDefinition(sd2);
if (!srData1.Name.StringEquals(sdData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (!srData1.Culture.StringEquals(sdData2.Culture.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (srData1.MajorVersion != sdData2.MajorVersion)
{
return(false);
}
if (srData1.MinorVersion != sdData2.MinorVersion)
{
return(false);
}
if (srData1.RevisionNumber != sdData2.RevisionNumber)
{
return(false);
}
if (srData1.BuildNumber != sdData2.BuildNumber)
{
return(false);
}
return(true);
}
public static bool CompareScopeReferenceAcrossModules(ScopeReferenceHandle sr1, MetadataReader mr1, ScopeReferenceHandle sr2, MetadataReader mr2)
{
ScopeReference srData1 = mr1.GetScopeReference(sr1);
ScopeReference srData2 = mr2.GetScopeReference(sr2);
if (!srData1.Name.StringEquals(srData2.Name.GetConstantStringValue(mr2).Value, mr1))
return false;
if (!srData1.Culture.StringEquals(srData2.Culture.GetConstantStringValue(mr2).Value, mr1))
return false;
if (srData1.MajorVersion != srData2.MajorVersion)
return false;
if (srData1.MinorVersion != srData2.MinorVersion)
return false;
if (srData1.RevisionNumber != srData2.RevisionNumber)
return false;
if (srData1.BuildNumber != srData2.BuildNumber)
return false;
return ComparePublicKeyOrTokens(srData1.PublicKeyOrToken, srData1.Flags.HasFlag(AssemblyFlags.PublicKey), srData2.PublicKeyOrToken, srData2.Flags.HasFlag(AssemblyFlags.PublicKey));
}
public ModuleDesc GetModule(ScopeReferenceHandle scopeHandle)
{
return((ModuleDesc)GetObject(scopeHandle, null));
}
private static RuntimeTypeInfo?TryResolveTypeReference(this TypeReferenceHandle typeReferenceHandle, MetadataReader reader, ref Exception?exception)
{
RuntimeTypeHandle resolvedRuntimeTypeHandle;
if (ReflectionCoreExecution.ExecutionEnvironment.TryGetNamedTypeForTypeReference(reader, typeReferenceHandle, out resolvedRuntimeTypeHandle))
{
return(resolvedRuntimeTypeHandle.GetTypeForRuntimeTypeHandle());
}
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
string name = typeReference.TypeName.GetString(reader);
Handle parent = typeReference.ParentNamespaceOrType;
HandleType parentType = parent.HandleType;
TypeInfo? outerTypeInfo = null;
// Check if this is a reference to a nested type.
if (parentType == HandleType.TypeDefinition)
{
outerTypeInfo = parent.ToTypeDefinitionHandle(reader).GetNamedType(reader);
}
else if (parentType == HandleType.TypeReference)
{
RuntimeTypeInfo?outerType = parent.ToTypeReferenceHandle(reader).TryResolveTypeReference(reader, ref exception);
if (outerType == null)
{
return(null);
}
outerTypeInfo = outerType; // Since we got to outerType via a metadata reference, we're assured GetTypeInfo() won't throw a MissingMetadataException.
}
if (outerTypeInfo != null)
{
// It was a nested type. We've already resolved the containing type recursively - just find the nested among its direct children.
TypeInfo?resolvedTypeInfo = outerTypeInfo.GetDeclaredNestedType(name);
if (resolvedTypeInfo == null)
{
exception = ReflectionCoreExecution.ExecutionDomain.CreateMissingMetadataException(outerTypeInfo, name);
return(null);
}
return(resolvedTypeInfo.CastToRuntimeTypeInfo());
}
// If we got here, the typeReference was to a non-nested type.
if (parentType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parent.ToNamespaceReferenceHandle(reader);
string fullName = namespaceReferenceHandle.ToFullyQualifiedTypeName(name, reader);
Handle parentHandleToSearch = parent;
while (parentHandleToSearch.HandleType != HandleType.ScopeReference)
{
parentHandleToSearch = parentHandleToSearch.ToNamespaceReferenceHandle(reader).GetNamespaceReference(reader).ParentScopeOrNamespace;
}
ScopeReferenceHandle scopeReferenceHandle = parentHandleToSearch.ToScopeReferenceHandle(reader);
RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader);
RuntimeAssemblyInfo runtimeAssembly;
exception = RuntimeAssemblyInfo.TryGetRuntimeAssembly(assemblyName, out runtimeAssembly);
if (exception != null)
{
return(null);
}
RuntimeTypeInfo runtimeType = runtimeAssembly.GetTypeCore(fullName, ignoreCase: false);
if (runtimeType == null)
{
exception = Helpers.CreateTypeLoadException(fullName, assemblyName.FullName);
return(null);
}
return(runtimeType);
}
throw new BadImageFormatException(); // Expected TypeReference parent to be typeRef, typeDef or namespaceRef.
}
