private Object ResolveQualifiedField(QualifiedFieldHandle handle)
{
QualifiedField qualifiedField = _metadataReader.GetQualifiedField(handle);
NativeFormatType enclosingType = (NativeFormatType)GetType(qualifiedField.EnclosingType);
return(GetField(qualifiedField.Field, enclosingType));
}
private Object ResolveQualifiedMethod(QualifiedMethodHandle handle)
{
QualifiedMethod qualifiedMethod = _metadataReader.GetQualifiedMethod(handle);
NativeFormatType enclosingType = (NativeFormatType)GetType(qualifiedMethod.EnclosingType);
return(GetMethod(qualifiedMethod.Method, enclosingType));
}
public MethodDesc GetMethod(Handle handle, NativeFormatType type)
{
MethodDesc method = GetObject(handle, type) as MethodDesc;
if (method == null)
{
throw new BadImageFormatException("Method expected");
}
return(method);
}
public FieldDesc GetField(Handle handle, NativeFormatType type)
{
FieldDesc field = GetObject(handle, type) as FieldDesc;
if (field == null)
{
throw new BadImageFormatException("Field expected");
}
return(field);
}
private TypeDesc[] _genericParameters; // TODO: Optional field?
internal NativeFormatMethod(NativeFormatType type, MethodHandle handle)
{
_type = type;
_handle = handle;
#if DEBUG
// Initialize name eagerly in debug builds for convenience
this.ToString();
#endif
}
private TypeDesc[] _genericParameters; // TODO: Optional field?
internal NativeFormatMethod(NativeFormatType type, MethodHandle handle)
{
_type = type;
_handle = handle;
#if DEBUG
// Initialize name eagerly in debug builds for convenience
this.ToString();
#endif
}
internal NativeFormatField(NativeFormatType type, FieldHandle handle)
{
_type = type;
_handle = handle;
#if DEBUG
// Initialize name eagerly in debug builds for convenience
InitializeName();
#endif
}
public Object GetObject(Handle handle, NativeFormatType type)
{
IHandleObject obj = _resolvedTokens.GetOrCreateValue(new NativeFormatObjectKey(handle, type));
if (obj is NativeFormatObjectLookupWrapper)
{
return(((NativeFormatObjectLookupWrapper)obj).Object);
}
else
{
return(obj);
}
}
public NativeFormatObjectKey(Handle handle, NativeFormatType container)
{
_handle = handle;
_container = container;
}
public NativeFormatObjectLookupWrapper(Handle handle, object obj, NativeFormatType container)
{
_obj = obj;
_handle = handle;
_container = container;
}
protected override IHandleObject CreateValueFromKey(NativeFormatObjectKey key)
{
Handle handle = key.Handle;
NativeFormatType container = key.Container;
object item;
switch (handle.HandleType)
{
case HandleType.TypeDefinition:
item = new NativeFormatType(_metadataUnit, handle.ToTypeDefinitionHandle(_metadataReader));
break;
case HandleType.Method:
item = new NativeFormatMethod(container, handle.ToMethodHandle(_metadataReader));
break;
case HandleType.Field:
item = new NativeFormatField(container, handle.ToFieldHandle(_metadataReader));
break;
case HandleType.TypeReference:
item = _metadataUnit.ResolveTypeReference(handle.ToTypeReferenceHandle(_metadataReader));
break;
case HandleType.MemberReference:
item = _metadataUnit.ResolveMemberReference(handle.ToMemberReferenceHandle(_metadataReader));
break;
case HandleType.QualifiedMethod:
item = _metadataUnit.ResolveQualifiedMethod(handle.ToQualifiedMethodHandle(_metadataReader));
break;
case HandleType.QualifiedField:
item = _metadataUnit.ResolveQualifiedField(handle.ToQualifiedFieldHandle(_metadataReader));
break;
case HandleType.ScopeReference:
item = _metadataUnit.ResolveAssemblyReference(handle.ToScopeReferenceHandle(_metadataReader));
break;
case HandleType.ScopeDefinition:
{
ScopeDefinition scope = handle.ToScopeDefinitionHandle(_metadataReader).GetScopeDefinition(_metadataReader);
item = _metadataUnit.GetModuleFromAssemblyName(scope.Name.GetConstantStringValue(_metadataReader).Value);
}
break;
case HandleType.TypeSpecification:
case HandleType.TypeInstantiationSignature:
case HandleType.SZArraySignature:
case HandleType.ArraySignature:
case HandleType.PointerSignature:
case HandleType.ByReferenceSignature:
case HandleType.TypeVariableSignature:
case HandleType.MethodTypeVariableSignature:
{
NativeFormatSignatureParser parser = new NativeFormatSignatureParser(_metadataUnit, handle, _metadataReader);
item = parser.ParseTypeSignature();
}
break;
case HandleType.MethodInstantiation:
item = _metadataUnit.ResolveMethodInstantiation(handle.ToMethodInstantiationHandle(_metadataReader));
break;
// TODO: Resolve other tokens
default:
throw new BadImageFormatException("Unknown metadata token type: " + handle.HandleType);
}
switch (handle.HandleType)
{
case HandleType.TypeDefinition:
case HandleType.Field:
case HandleType.Method:
// type/method/field definitions directly correspond to their target item.
return((IHandleObject)item);
default:
// Everything else is some form of reference which cannot be self-describing
return(new NativeFormatObjectLookupWrapper(handle, item, container));
}
}
// Todo: This is looking up the hierarchy to DefType and ParameterizedType. It should really
// call a virtual or an outside type to handle those parts
internal bool RetrieveRuntimeTypeHandleIfPossible()
{
TypeDesc type = this;
if (!type.RuntimeTypeHandle.IsNull())
{
return(true);
}
TypeBuilderState state = GetTypeBuilderStateIfExist();
if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle)
{
return(false);
}
if (type is DefType)
{
DefType typeAsDefType = (DefType)type;
TypeDesc typeDefinition = typeAsDefType.GetTypeDefinition();
RuntimeTypeHandle typeDefHandle = typeDefinition.RuntimeTypeHandle;
if (typeDefHandle.IsNull())
{
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
NativeFormat.NativeFormatType mdType = typeDefinition as NativeFormat.NativeFormatType;
if (mdType != null)
{
// Look up the runtime type handle in the module metadata
if (TypeLoaderEnvironment.Instance.TryGetNamedTypeForMetadata(new QTypeDefinition(mdType.MetadataReader, mdType.Handle), out typeDefHandle))
{
typeDefinition.SetRuntimeTypeHandleUnsafe(typeDefHandle);
}
}
#endif
#if ECMA_METADATA_SUPPORT
Ecma.EcmaType ecmaType = typeDefinition as Ecma.EcmaType;
if (ecmaType != null)
{
// Look up the runtime type handle in the module metadata
if (TypeLoaderEnvironment.Instance.TryGetNamedTypeForMetadata(new QTypeDefinition(ecmaType.MetadataReader, ecmaType.Handle), out typeDefHandle))
{
typeDefinition.SetRuntimeTypeHandleUnsafe(typeDefHandle);
}
}
#endif
}
if (!typeDefHandle.IsNull())
{
Instantiation instantiation = typeAsDefType.Instantiation;
if ((instantiation.Length > 0) && !typeAsDefType.IsGenericDefinition)
{
// Generic type. First make sure we have type handles for the arguments, then check
// the instantiation.
bool argumentsRegistered = true;
bool arrayArgumentsFound = false;
for (int i = 0; i < instantiation.Length; i++)
{
if (!instantiation[i].RetrieveRuntimeTypeHandleIfPossible())
{
argumentsRegistered = false;
arrayArgumentsFound = arrayArgumentsFound || (instantiation[i] is ArrayType);
}
}
RuntimeTypeHandle rtth;
// If at least one of the arguments is not known to the runtime, we take a slower
// path to compare the current type we need a handle for to the list of generic
// types statically available, by loading them as DefTypes and doing a DefType comparaison
if ((argumentsRegistered && TypeLoaderEnvironment.Instance.TryLookupConstructedGenericTypeForComponents(new TypeLoaderEnvironment.HandleBasedGenericTypeLookup(typeAsDefType), out rtth)) ||
(arrayArgumentsFound && TypeLoaderEnvironment.Instance.TryLookupConstructedGenericTypeForComponents(new TypeLoaderEnvironment.DefTypeBasedGenericTypeLookup(typeAsDefType), out rtth)))
{
typeAsDefType.SetRuntimeTypeHandleUnsafe(rtth);
return(true);
}
}
else
{
// Nongeneric, or generic type def types are just the type handle of the type definition as found above
type.SetRuntimeTypeHandleUnsafe(typeDefHandle);
return(true);
}
}
}
else if (type is ParameterizedType)
{
ParameterizedType typeAsParameterType = (ParameterizedType)type;
if (typeAsParameterType.ParameterType.RetrieveRuntimeTypeHandleIfPossible())
{
RuntimeTypeHandle rtth;
if ((type is ArrayType &&
(TypeLoaderEnvironment.Instance.TryGetArrayTypeForElementType_LookupOnly(typeAsParameterType.ParameterType.RuntimeTypeHandle, type.IsMdArray, type.IsMdArray ? ((ArrayType)type).Rank : -1, out rtth) ||
TypeLoaderEnvironment.Instance.TryGetArrayTypeHandleForNonDynamicArrayTypeFromTemplateTable(type as ArrayType, out rtth)))
||
(type is PointerType && TypeSystemContext.PointerTypesCache.TryGetValue(typeAsParameterType.ParameterType.RuntimeTypeHandle, out rtth)))
{
typeAsParameterType.SetRuntimeTypeHandleUnsafe(rtth);
return(true);
}
else if (type is ByRefType)
{
// Byref types don't have any associated type handles, so return success at this point
// since we were able to resolve the typehandle of the element type
return(true);
}
}
}
else if (type is SignatureVariable)
{
// SignatureVariables do not have RuntimeTypeHandles
}
else
{
Debug.Assert(false);
}
// Make a note on the type build state that we have attempted to retrieve RuntimeTypeHandle but there is not one
GetOrCreateTypeBuilderState().AttemptedAndFailedToRetrieveTypeHandle = true;
return(false);
}
