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)); }