/// <summary>
/// This method resolves TypeRef as a non exported type. i.e. the said type reference refers to the type
/// in the type def table direcly rather than exported type table of the assembly.
/// </summary>
/// <param name="moduleTypeRefReference"></param>
/// <returns></returns>
internal TypeBase/*?*/ ResolveModuleTypeRefReference(
TypeRefReference moduleTypeRefReference
) {
uint typeRefRowId = moduleTypeRefReference.TypeRefRowId;
if (typeRefRowId == 0) {
return null;
}
TypeRefRow typeRefRow = this.PEFileReader.TypeRefTable[typeRefRowId];
IName namespaceName = this.GetNameFromOffset(typeRefRow.Namespace);
IName typeName = moduleTypeRefReference.MangledTypeName;
uint resolutionScope = typeRefRow.ResolutionScope;
uint tokenType = resolutionScope & TokenTypeIds.TokenTypeMask;
uint rowId = resolutionScope & TokenTypeIds.RIDMask;
TypeBase/*?*/ retModuleType = null;
switch (tokenType) {
case TokenTypeIds.Module:
retModuleType = this.ResolveNamespaceTypeDefinition(namespaceName, typeName);
break;
case TokenTypeIds.ModuleRef: {
ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(rowId);
if (modRef != null) {
Module/*?*/ module = this.ResolveModuleRefReference(modRef);
if (module != null) {
PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel;
retModuleType = modulePEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, typeName);
if (retModuleType != null)
return retModuleType;
}
}
break;
}
case TokenTypeIds.AssemblyRef: {
AssemblyReference/*?*/ assemRef = this.GetAssemblyReferenceAt(rowId);
if (assemRef == null) {
return null;
}
var internalAssembly = assemRef.ResolvedAssembly as Assembly;
if (internalAssembly != null) {
PEFileToObjectModel assemblyPEFileToObjectModel = internalAssembly.PEFileToObjectModel;
retModuleType = assemblyPEFileToObjectModel.ResolveNamespaceTypeDefinition(namespaceName, typeName);
if (retModuleType != null) {
return retModuleType;
}
break;
}
break;
}
case TokenTypeIds.TypeRef: {
TypeRefReference/*?*/ parentTypeReference = this.GetTypeRefReferenceAtRowWorker(rowId);
if (parentTypeReference == null) {
return null;
}
TypeBase/*?*/ parentModuleType = this.ResolveModuleTypeRefReference(parentTypeReference);
if (parentModuleType != null) {
retModuleType = parentModuleType.PEFileToObjectModel.ResolveNestedTypeDefinition(parentModuleType, typeName);
}
break;
}
default:
break;
}
return retModuleType;
}
//^ invariant this.PEFileReader.TypeSpecTable.NumberOfRows >= 1 ==> this.ModuleTypeSpecHashtable != null;
TypeRefReference CreateTypeRefReference(
uint typeRefRowId,
TypeRefRow typeRefRow,
TypeRefReference/*?*/ parentModuleTypeReference,
IModuleModuleReference moduleReference,
ModuleSignatureTypeCode signatureTypeCode
) {
IName mangledTypeName = this.GetNameFromOffset(typeRefRow.Name);
ushort genericParamCount;
string typeName;
TypeCache.SplitMangledTypeName(mangledTypeName.Value, out typeName, out genericParamCount);
TypeRefReference moduleTypeRefReference;
if (parentModuleTypeReference == null) {
IName namespaceFullName = this.GetNameFromOffset(typeRefRow.Namespace);
NamespaceReference namespaceReference = this.GetNamespaceReferenceForString(moduleReference, namespaceFullName);
if (genericParamCount == 0) {
if (signatureTypeCode == ModuleSignatureTypeCode.NotModulePrimitive) {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithoutPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
} else {
moduleTypeRefReference = new NamespaceTypeRefReferenceWithPrimitiveTypeCode(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
signatureTypeCode
);
}
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNamespaceTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
namespaceReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
}
} else {
if (genericParamCount == 0) {
moduleTypeRefReference = new NonGenericNestedTypeRefReference(
this,
mangledTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
} else {
IName iTypeName = this.NameTable.GetNameFor(typeName);
moduleTypeRefReference = new GenericNestedTypeRefReference(
this,
iTypeName,
typeRefRowId,
moduleReference,
parentModuleTypeReference,
mangledTypeName,
genericParamCount,
signatureTypeCode == ModuleSignatureTypeCode.ValueType
);
}
}
return moduleTypeRefReference;
}
