TypeDef ResolveExportedType(IList<ModuleDef> modules, TypeRef typeRef) {
var exportedType = FindExportedType(modules, typeRef);
if (exportedType == null)
return null;
var asmResolver = modules[0].Context.AssemblyResolver;
var etAsm = asmResolver.Resolve(exportedType.DefinitionAssembly, typeRef.Module);
if (etAsm == null)
return null;
return etAsm.Find(typeRef);
}
/// <summary>
/// Gets a type color
/// </summary>
/// <param name="type">Type</param>
/// <returns></returns>
public virtual object GetColor(TypeRef type) {
if (type == null)
return BoxedTextColor.Text;
var td = type.Resolve();
if (td != null)
return GetColor(td);
return BoxedTextColor.Type;
}
/// <summary>
/// Checks whether the type matches an expected type
/// </summary>
/// <param name="module">Module</param>
/// <param name="name">Type name</param>
/// <param name="expectedType">Expected type</param>
/// <returns></returns>
public static bool CheckType(ModuleDef module, string name, TypeRef expectedType) {
if (module == null)
module = new ModuleDefUser();
var tr = TypeNameParser.ParseReflection(module, name, null);
if (tr == null)
return false;
var flags = AssemblyNameComparerFlags.All & ~AssemblyNameComparerFlags.Version;
if (!new AssemblyNameComparer(flags).Equals(tr.DefinitionAssembly, expectedType.DefinitionAssembly))
return false;
if (!new SigComparer().Equals(tr, expectedType))
return false;
return true;
}
TypeDef ResolveExportedType(IList<ModuleDef> modules, TypeRef typeRef, ModuleDef sourceModule) {
for (int i = 0; i < 30; i++) {
var exportedType = FindExportedType(modules, typeRef);
if (exportedType == null)
return null;
var asmResolver = modules[0].Context.AssemblyResolver;
var etAsm = asmResolver.Resolve(exportedType.DefinitionAssembly, sourceModule ?? typeRef.Module);
if (etAsm == null)
return null;
var td = etAsm.Find(typeRef);
if (td != null)
return td;
modules = etAsm.Modules;
}
return null;
}
/// <inheritdoc/>
public TypeDef Resolve(TypeRef typeRef, ModuleDef sourceModule) {
if (typeRef == null)
return null;
if (ProjectWinMDRefs)
typeRef = WinMDHelpers.ToCLR(typeRef.Module ?? sourceModule, typeRef) ?? typeRef;
var nonNestedTypeRef = TypeRef.GetNonNestedTypeRef(typeRef);
if (nonNestedTypeRef == null)
return null;
var nonNestedResolutionScope = nonNestedTypeRef.ResolutionScope;
var nonNestedModule = nonNestedTypeRef.Module;
var asmRef = nonNestedResolutionScope as AssemblyRef;
if (asmRef != null) {
var asm = assemblyResolver.Resolve(asmRef, sourceModule ?? nonNestedModule);
return asm == null ? null : asm.Find(typeRef) ?? ResolveExportedType(asm.Modules, typeRef, sourceModule);
}
var moduleDef = nonNestedResolutionScope as ModuleDef;
if (moduleDef != null)
return moduleDef.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { moduleDef }, typeRef, sourceModule);
var moduleRef = nonNestedResolutionScope as ModuleRef;
if (moduleRef != null) {
if (nonNestedModule == null)
return null;
if (new SigComparer().Equals(moduleRef, nonNestedModule))
return nonNestedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { nonNestedModule }, typeRef, sourceModule);
var nonNestedAssembly = nonNestedModule.Assembly;
if (nonNestedAssembly == null)
return null;
var resolvedModule = nonNestedAssembly.FindModule(moduleRef.Name);
return resolvedModule == null ? null : resolvedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { resolvedModule }, typeRef, sourceModule);
}
return null;
}
/// <inheritdoc/>
public AssemblyRef FindAssemblyRef(TypeRef nonNestedTypeRef) {
var modAsm = module.Assembly;
if (modAsm != null) {
var type = modAsm.Find(nonNestedTypeRef);
if (type != null)
return module.UpdateRowId(new AssemblyRefUser(modAsm));
}
else if (module.Find(nonNestedTypeRef) != null)
return AssemblyRef.CurrentAssembly;
var corLibAsm = module.Context.AssemblyResolver.Resolve(module.CorLibTypes.AssemblyRef, module);
if (corLibAsm != null) {
var type = corLibAsm.Find(nonNestedTypeRef);
if (type != null)
return module.CorLibTypes.AssemblyRef;
}
if (modAsm != null)
return module.UpdateRowId(new AssemblyRefUser(modAsm));
return AssemblyRef.CurrentAssembly;
}
/// <summary>
/// Returns the owner module. The type was created from metadata in this module.
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <returns>A <see cref="ModuleDef"/> or <c>null</c> if none found</returns>
public static ModuleDef OwnerModule(TypeRef typeRef) {
return new FullNameCreator().GetOwnerModule(typeRef);
}
/// <summary>
/// Returns the assembly where this type is defined
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <returns>A <see cref="IAssembly"/> or <c>null</c> if none found</returns>
public static IAssembly DefinitionAssembly(TypeRef typeRef) {
return new FullNameCreator().GetDefinitionAssembly(typeRef);
}
/// <summary>
/// Returns the assembly qualified full name of a <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <returns>The assembly qualified full name</returns>
public static string AssemblyQualifiedName(TypeRef typeRef) {
return AssemblyQualifiedName(typeRef, null);
}
/// <summary>
/// Returns the full name of a <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <param name="isReflection">Set if output should be compatible with reflection</param>
/// <returns>The full name</returns>
public static string FullName(TypeRef typeRef, bool isReflection) {
return FullName(typeRef, isReflection, null);
}
ModuleDef GetOwnerModule(TypeRef typeRef) {
if (typeRef == null)
return null;
return typeRef.Module;
}
IAssembly GetDefinitionAssembly(TypeRef typeRef) {
if (typeRef == null)
return null;
if (!recursionCounter.Increment())
return null;
IAssembly result;
var scope = typeRef.ResolutionScope;
if (scope == null)
result = null; //TODO: Check ownerModule's ExportedType table
else if (scope is TypeRef)
result = GetDefinitionAssembly((TypeRef)scope);
else if (scope is AssemblyRef)
result = (AssemblyRef)scope;
else if (scope is ModuleRef) {
var ownerModule = GetOwnerModule(typeRef);
result = ownerModule == null ? null : ownerModule.Assembly;
}
else if (scope is ModuleDef)
result = ((ModuleDef)scope).Assembly;
else
result = null; // Should never be reached
recursionCounter.Decrement();
return result;
}
TypeDef Resolve(AssemblyRef asmRef, TypeRef typeRef) {
var asm = ownerModule.Assembly;
if (asm == null)
return null;
if (asmRef.FullName != asm.GetFullNameWithPublicKey() && asmRef.FullName != asm.GetFullNameWithPublicKeyToken())
return null;
var td = typeRef.Resolve();
return td != null && td.Module == ownerModule ? td : null;
}
/// <inheritdoc/>
public TypeDef Resolve(TypeRef typeRef, ModuleDef sourceModule)
{
if (typeRef == null)
{
return(null);
}
if (ProjectWinMDRefs)
{
typeRef = WinMDHelpers.ToCLR(typeRef.Module ?? sourceModule, typeRef) ?? typeRef;
}
var nonNestedTypeRef = TypeRef.GetNonNestedTypeRef(typeRef);
if (nonNestedTypeRef == null)
{
return(null);
}
var nonNestedResolutionScope = nonNestedTypeRef.ResolutionScope;
var nonNestedModule = nonNestedTypeRef.Module;
var asmRef = nonNestedResolutionScope as AssemblyRef;
if (asmRef != null)
{
var asm = assemblyResolver.Resolve(asmRef, sourceModule ?? nonNestedModule);
return(asm == null ? null : asm.Find(typeRef) ?? ResolveExportedType(asm.Modules, typeRef, sourceModule));
}
var moduleDef = nonNestedResolutionScope as ModuleDef;
if (moduleDef != null)
{
return(moduleDef.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { moduleDef }, typeRef, sourceModule));
}
var moduleRef = nonNestedResolutionScope as ModuleRef;
if (moduleRef != null)
{
if (nonNestedModule == null)
{
return(null);
}
if (new SigComparer().Equals(moduleRef, nonNestedModule))
{
return(nonNestedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { nonNestedModule }, typeRef, sourceModule));
}
var nonNestedAssembly = nonNestedModule.Assembly;
if (nonNestedAssembly == null)
{
return(null);
}
var resolvedModule = nonNestedAssembly.FindModule(moduleRef.Name);
return(resolvedModule == null ? null : resolvedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { resolvedModule }, typeRef, sourceModule));
}
return(null);
}
internal bool IsValueType(TypeRef typeRef) => typeRef is not null && typeRef.IsValueType;
void CreateFullName(TypeRef typeRef) {
if (typeRef == null) {
sb.Append(NULLVALUE);
return;
}
if (!recursionCounter.Increment()) {
sb.Append(RECURSION_ERROR_RESULT_STRING);
return;
}
var declaringTypeRef = typeRef.ResolutionScope as TypeRef;
if (declaringTypeRef != null) {
CreateFullName(declaringTypeRef);
AddNestedTypeSeparator();
}
if (AddNamespace(typeRef.Namespace))
sb.Append('.');
AddName(typeRef.Name);
recursionCounter.Decrement();
}
bool ContainsGenericParameterInternal(TypeRef type)
{
return(false);
}
/// <inheritdoc/>
public TypeDef Find(TypeRef typeRef) {
if (typeRef == null)
return null;
return isCacheEnabled ? FindCache(typeRef) : FindSlow(typeRef);
}
/// <summary>
/// Checks whether it can access a <see cref="TypeRef"/>
/// </summary>
/// <param name="tr">The type</param>
/// <returns><c>true</c> if it has access to it, <c>false</c> if not, and <c>null</c>
/// if we can't determine it (eg. we couldn't resolve a type or input was <c>null</c>)</returns>
public bool? CanAccess(TypeRef tr) {
if (tr == null)
return null;
return CanAccess(tr.Resolve());
}
TypeDef FindCache(TypeRef typeRef) {
TypeDef cachedType;
if (typeRefCache.TryGetValue(typeRef, out cachedType))
return cachedType;
// Build the cache lazily
var comparer = new SigComparer { Options = TypeComparerOptions };
while (true) {
cachedType = GetNextTypeDefCache();
if (cachedType == null || comparer.Equals(cachedType, typeRef))
return cachedType;
}
}
IScope GetScope(TypeRef typeRef) {
if (typeRef == null)
return null;
if (!recursionCounter.Increment())
return null;
IScope result;
TypeRef tr;
AssemblyRef asmRef;
ModuleRef modRef;
ModuleDef modDef;
var scope = typeRef.ResolutionScope;
if (scope == null)
result = null; //TODO: Check ownerModule's ExportedType table
else if ((tr = scope as TypeRef) != null)
result = GetScope(tr);
else if ((asmRef = scope as AssemblyRef) != null)
result = asmRef;
else if ((modRef = scope as ModuleRef) != null)
result = modRef;
else if ((modDef = scope as ModuleDef) != null)
result = modDef;
else
result = null; // Should never be reached
recursionCounter.Decrement();
return result;
}
TypeDef FindSlow(TypeRef typeRef) {
InitializeTypeEnumerator();
var comparer = new SigComparer { Options = TypeComparerOptions };
while (true) {
var type = GetNextTypeDef();
if (type == null || comparer.Equals(type, typeRef))
return type;
}
}
/// <summary>
/// Returns the name of a <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <param name="isReflection">Set if output should be compatible with reflection</param>
/// <returns>The name</returns>
public static string Name(TypeRef typeRef, bool isReflection) {
var fnc = new FullNameCreator(isReflection, null);
fnc.CreateName(typeRef);
return fnc.Result;
}
public AssemblyRef FindAssemblyRef(TypeRef nonNestedTypeRef)
{
return assemblyDef.ToAssemblyRef();
}
/// <summary>
/// Returns the full name of a <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <param name="isReflection">Set if output should be compatible with reflection</param>
/// <param name="helper">Helps print the name</param>
/// <returns>The full name</returns>
public static string FullName(TypeRef typeRef, bool isReflection, IFullNameCreatorHelper helper) {
var fnc = new FullNameCreator(isReflection, helper);
fnc.CreateFullName(typeRef);
return fnc.Result;
}
/// <summary>
/// Gets the top-most (non-nested) <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">Input</param>
/// <returns>The non-nested <see cref="TypeRef"/> or <c>null</c></returns>
internal static TypeRef GetNonNestedTypeRef(TypeRef typeRef) {
if (typeRef == null)
return null;
for (int i = 0; i < 1000; i++) {
var next = typeRef.ResolutionScope as TypeRef;
if (next == null)
return typeRef;
typeRef = next;
}
return null; // Should never happen
}
/// <summary>
/// Returns the assembly qualified full name of a <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <param name="helper">Helps print the name</param>
/// <returns>The assembly qualified full name</returns>
public static string AssemblyQualifiedName(TypeRef typeRef, IFullNameCreatorHelper helper) {
var fnc = new FullNameCreator(true, helper);
fnc.CreateAssemblyQualifiedName(typeRef);
return fnc.Result;
}
/// <summary>
/// Gets the top-most (non-nested) <see cref="TypeRef"/>
/// </summary>
/// <param name="typeRef">Input</param>
/// <returns>The non-nested <see cref="TypeRef"/> or <c>null</c></returns>
internal static TypeRef GetNonNestedTypeRef(TypeRef typeRef) {
if (typeRef == null)
return null;
for (int i = 0; i < 1000; i++) {
var next = typeRef.ResolutionScope as TypeRef;
if (next == null)
return typeRef;
typeRef = next;
}
return null; // Here if eg. the TypeRef has an infinite loop
}
/// <summary>
/// Gets the scope
/// </summary>
/// <param name="typeRef">The <c>TypeRef</c></param>
/// <returns>The <see cref="IScope"/> or <c>null</c> if none found</returns>
public static IScope Scope(TypeRef typeRef) {
return new FullNameCreator().GetScope(typeRef);
}
internal AssemblyRef FindAssemblyRef(TypeRef nonNestedTypeRef) {
AssemblyRef asmRef = null;
if (nonNestedTypeRef != null && typeNameParserHelper != null)
asmRef = typeNameParserHelper.FindAssemblyRef(nonNestedTypeRef);
if (asmRef != null)
return asmRef;
if (ownerModule.Assembly != null)
return ownerModule.UpdateRowId(ownerModule.Assembly.ToAssemblyRef());
return AssemblyRef.CurrentAssembly;
}
void CreateAssemblyQualifiedName(TypeRef typeRef) {
if (typeRef == null) {
sb.Append(NULLVALUE);
return;
}
if (!recursionCounter.Increment()) {
sb.Append(RECURSION_ERROR_RESULT_STRING);
return;
}
CreateFullName(typeRef);
if (MustUseAssemblyName(typeRef))
AddAssemblyName(GetDefinitionAssembly(typeRef));
recursionCounter.Decrement();
}
internal bool IsValueType(TypeRef typeRef) {
return typeRef != null && typeRef.IsValueType;
}
void CreateName(TypeRef typeRef) {
if (typeRef == null) {
sb.Append(NULLVALUE);
return;
}
AddName(typeRef.Name);
}
/// <summary>
/// Checks whether <paramref name="type"/> contains a <see cref="GenericVar"/> or a
/// <see cref="GenericMVar"/>.
/// </summary>
/// <param name="type">Type</param>
/// <returns><c>true</c> if <paramref name="type"/> contains a <see cref="GenericVar"/> or a
/// <see cref="GenericMVar"/>.</returns>
public static bool ContainsGenericParameter(TypeRef type)
{
return(new TypeHelper().ContainsGenericParameterInternal(type));
}
