IMemberRefParent Import(IMemberRefParent parent) { var tdr = parent as ITypeDefOrRef; if (tdr != null) { var td = tdr as TypeDef; if (td != null && td.IsGlobalModuleType) { var om = td.Module; return(module.UpdateRowId(new ModuleRefUser(module, om == null ? null : om.Name))); } return(Import(tdr)); } var modRef = parent as ModuleRef; if (modRef != null) { return(module.UpdateRowId(new ModuleRefUser(module, modRef.Name))); } var method = parent as MethodDef; if (method != null) { var dt = method.DeclaringType; return(dt == null || dt.Module != module ? null : method); } return(null); }
public MemberRefOptions(MemberRef mr) { this.Class = mr.Class; this.Name = mr.Name; this.Signature = mr.Signature; this.CustomAttributes.AddRange(mr.CustomAttributes); }
/// <summary> /// Creates a new reference to a member in an (external) .NET assembly. /// </summary> /// <param name="parent">The declaring member that defines the referenced member.</param> /// <param name="name">The name of the referenced member.</param> /// <param name="signature">The signature of the referenced member. This dictates whether the /// referenced member is a field or a method.</param> public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : this(new MetadataToken(TableIndex.MemberRef, 0)) { Parent = parent; Name = name; Signature = signature; }
public MetadataToken GetMemberRefParentToken(IMemberRefParent parent) { AssertIsImported(parent); var type = parent as ITypeDefOrRef; if (type != null) { return(GetTypeToken(type)); } var method = parent as MethodDefinition; if (method != null) { return(GetNewToken(method)); } var reference = parent as ModuleReference; if (reference != null) { return(GetModuleReferenceToken(reference)); } throw new NotSupportedException("Invalid or unsupported MemberRefParent reference " + parent + "."); }
public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : base(null, new MetadataToken(MetadataTokenType.MemberRef), new MetadataRow <uint, uint, uint>()) { _parent = new LazyValue <IMemberRefParent>(parent); _name = new LazyValue <string>(name); _signature = new LazyValue <MemberSignature>(signature); }
/// <summary> /// Determines whether two member parents are considered equal according to their signature. /// </summary> /// <param name="parent1">The first member parent to compare.</param> /// <param name="parent2">The second member parent to compare.</param> /// <returns><c>True</c> if the parents are considered equal, <c>False</c> otherwise.</returns> public bool Equals(IMemberRefParent parent1, IMemberRefParent parent2) { if (parent1 == null && parent2 == null) { return(true); } if (parent1 == null || parent2 == null) { return(false); } var type = parent1 as ITypeDefOrRef; if (type != null) { return(Equals(type, parent2 as ITypeDefOrRef)); } var moduleRef = parent1 as ModuleReference; if (moduleRef != null) { return(Equals(moduleRef, parent2 as ModuleReference)); } return(false); }
/// <summary> /// Constructor /// </summary> /// <param name="module">Owner module</param> /// <param name="name">Name of method ref</param> /// <param name="sig">Method sig</param> /// <param name="class">Owner of method</param> public MemberRefUser(ModuleDef module, UTF8String name, MethodSig sig, IMemberRefParent @class) { this.module = module; this.name = name; this.@class = @class; this.signature = sig; }
public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : base(new MetadataToken(MetadataTokenType.MemberRef)) { _parent = new LazyValue <IMemberRefParent>(parent); _name = new LazyValue <string>(name); _signature = new LazyValue <MemberSignature>(signature); CustomAttributes = new CustomAttributeCollection(this); }
/// <summary> /// Imports a parent of a member reference into the assembly. /// </summary> /// <param name="parent">The parent to import.</param> /// <returns>The imported parent.</returns> public IMemberRefParent ImportMemberRefParent(IMemberRefParent parent) { switch (parent) { case ITypeDefOrRef type: return(ImportType(type)); case ModuleReference moduleRef: return(ImportModule(moduleRef)); default: throw new NotSupportedException(); } }
public MemberRef Method(bool isInstance, string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { MethodSig sig; if (isInstance) { sig = MethodSig.CreateInstance(returnType, args); } else { sig = MethodSig.CreateStatic(returnType, args); } return(module.UpdateRowId(new MemberRefUser(module, name, sig, declaringType))); }
static bool Equals(IMemberRefParent @class, TypeDef type) { if (@class == null || type == null) { return(false); } if (@class is TypeDef td) { return(TypeEqualityComparerInstance.Equals(td, type)); } if (@class is TypeRef tr) { return(TypeEqualityComparerInstance.Equals(tr, type)); } if (@class is TypeSpec ts) { var typeSig = ts.TypeSig.RemovePinnedAndModifiers(); var tdrSig = typeSig as TypeDefOrRefSig; if (tdrSig == null && typeSig is GenericInstSig gis) { tdrSig = gis.GenericType; } if (tdrSig != null) { if (tdrSig.TypeDefOrRef is TypeDef td2) { return(TypeEqualityComparerInstance.Equals(td2, type)); } if (tdrSig.TypeDefOrRef is TypeRef tr2) { return(TypeEqualityComparerInstance.Equals(tr2, type)); } return(false); } return(false); } if (@class is MethodDef md) { return(TypeEqualityComparerInstance.Equals(md.DeclaringType, type)); } if (@class is ModuleRef mr) { return(type.IsGlobalModuleType && StringComparer.OrdinalIgnoreCase.Equals(mr.Name, type.Module.Name)); } return(false); }
public IMemberRefParent ImportMemberRefParent(IMemberRefParent parent) { var type = parent as ITypeDefOrRef; if (type != null) { return(ImportType(type)); } var moduleRef = parent as ModuleReference; if (moduleRef != null) { return(ImportModule(moduleRef)); } throw new NotSupportedException(); }
private uint AddMemberRefParent(IMemberRefParent parent) { if (parent is null || !AssertIsImported(parent)) { return(0); } var token = parent.MetadataToken.Table switch { TableIndex.TypeDef => GetTypeDefinitionToken(parent as TypeDefinition), TableIndex.TypeRef => GetTypeReferenceToken(parent as TypeReference), TableIndex.TypeSpec => GetTypeSpecificationToken(parent as TypeSpecification), TableIndex.Method => GetMethodDefinitionToken(parent as MethodDefinition), TableIndex.ModuleRef => GetModuleReferenceToken(parent as ModuleReference), _ => throw new ArgumentOutOfRangeException(nameof(parent)) }; return(Metadata.TablesStream .GetIndexEncoder(CodedIndex.MemberRefParent) .EncodeToken(token)); }
string GetDeclaringTypeFullName(IMemberRefParent parent) { if (parent == null) { return(null); } if (parent is ITypeDefOrRef) { return(((ITypeDefOrRef)parent).FullName); } if (parent is ModuleRef) { return(string.Format("[module:{0}]<Module>", ((ModuleRef)parent).ToString())); } if (parent is MethodDef) { var declaringType = ((MethodDef)parent).DeclaringType; return(declaringType == null ? null : declaringType.FullName); } return(null); // Should never be reached }
/// <summary> /// Determines whether two member parents are considered equal according to their signature. /// </summary> /// <param name="parent1">The first member parent to compare.</param> /// <param name="parent2">The second member parent to compare.</param> /// <returns><c>True</c> if the parents are considered equal, <c>False</c> otherwise.</returns> public bool Equals(IMemberRefParent parent1, IMemberRefParent parent2) { if (parent1 == null && parent2 == null) { return(true); } if (parent1 == null || parent2 == null) { return(false); } switch (parent1) { case ITypeDefOrRef type: return(Equals(type, parent2 as ITypeDefOrRef)); case ModuleReference moduleRef: return(Equals(moduleRef, parent2 as ModuleReference)); default: return(false); } }
string GetDeclaringTypeFullName(IMemberRefParent parent) { if (parent == null) return null; if (parent is ITypeDefOrRef) return ((ITypeDefOrRef)parent).FullName; if (parent is ModuleRef) return string.Format("[module:{0}]<Module>", ((ModuleRef)parent).ToString()); if (parent is MethodDef) { var declaringType = ((MethodDef)parent).DeclaringType; return declaringType == null ? null : declaringType.FullName; } return null; // Should never be reached }
static bool IsFromNonObfuscatedAssembly(IMemberRefParent mrp) { return IsFromNonObfuscatedAssembly(mrp as TypeRef); }
public IMemberRefParent ImportMemberRefParent(IMemberRefParent parent) { var type = parent as ITypeDefOrRef; if (type != null) return ImportType(type); var moduleRef = parent as ModuleReference; if (moduleRef != null) return ImportModule(moduleRef); throw new NotSupportedException(); }
TypeDef GetDeclaringType(MemberRef memberRef, IMemberRefParent parent) { if (memberRef == null || parent == null) return null; var declaringTypeDef = parent as TypeDef; if (declaringTypeDef != null) return declaringTypeDef; var declaringTypeRef = parent as TypeRef; if (declaringTypeRef != null) return Resolve(declaringTypeRef); // A module ref is used to reference the global type of a module in the same // assembly as the current module. var moduleRef = parent as ModuleRef; if (moduleRef != null) { var module = memberRef.Module; if (module == null) return null; TypeDef globalType = null; if (new SigComparer(0).Equals(module, moduleRef)) globalType = module.GlobalType; var modAsm = module.Assembly; if (globalType == null && modAsm != null) { var moduleDef = modAsm.FindModule(moduleRef.Name); if (moduleDef != null) globalType = moduleDef.GlobalType; } return globalType; } var method = parent as MethodDef; if (method != null) return method.DeclaringType; var ts = parent as TypeSpec; if (ts != null) { var git = ts.TypeSig as GenericInstSig; if (git != null) { var td = git.GenericType.TypeDef; if (td != null) return td; var tr = git.GenericType.TypeRef; if (tr != null) return Resolve(tr); } return null; } return null; }
/// <summary> /// Gets a <see cref="GenericParamContext"/> that can be used as signature context /// </summary> /// <param name="gpContext">Context passed to the constructor</param> /// <param name="class">Field/method class owner</param> /// <returns></returns> protected static GenericParamContext GetSignatureGenericParamContext(GenericParamContext gpContext, IMemberRefParent @class) { TypeDef type = null; MethodDef method = gpContext.Method; var ts = @class as TypeSpec; if (ts != null) { var gis = ts.TypeSig as GenericInstSig; if (gis != null) type = gis.GenericType.ToTypeDefOrRef().ResolveTypeDef(); } return new GenericParamContext(type, method); }
static bool IsFromNonObfuscatedAssembly(IMemberRefParent mrp) { return(IsFromNonObfuscatedAssembly(mrp as TypeRef)); }
public MemberRef Method(bool isInstance, string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { MethodSig sig; if (isInstance) sig = MethodSig.CreateInstance(returnType, args); else sig = MethodSig.CreateStatic(returnType, args); return module.UpdateRowId(new MemberRefUser(module, name, sig, declaringType)); }
public MemberRef InstanceMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { return(Method(true, name, declaringType, returnType, args)); }
/// <summary> /// Gets a <see cref="GenericParamContext"/> that can be used as signature context /// </summary> /// <param name="gpContext">Context passed to the constructor</param> /// <param name="class">Field/method class owner</param> /// <returns></returns> protected static GenericParamContext GetSignatureGenericParamContext(GenericParamContext gpContext, IMemberRefParent @class) { TypeDef type = null; MethodDef method = gpContext.Method; var ts = @class as TypeSpec; if (ts != null) { var gis = ts.TypeSig as GenericInstSig; if (gis != null) { type = gis.GenericType.ToTypeDefOrRef().ResolveTypeDef(); } } return(new GenericParamContext(type, method)); }
TypeDef GetDeclaringType(MemberRef memberRef, IMemberRefParent parent) { if (memberRef == null || parent == null) { return(null); } var ts = parent as TypeSpec; if (ts != null) { parent = ts.ScopeType; } var declaringTypeDef = parent as TypeDef; if (declaringTypeDef != null) { return(declaringTypeDef); } var declaringTypeRef = parent as TypeRef; if (declaringTypeRef != null) { return(Resolve(declaringTypeRef, memberRef.Module)); } // A module ref is used to reference the global type of a module in the same // assembly as the current module. var moduleRef = parent as ModuleRef; if (moduleRef != null) { var module = memberRef.Module; if (module == null) { return(null); } TypeDef globalType = null; if (new SigComparer().Equals(module, moduleRef)) { globalType = module.GlobalType; } var modAsm = module.Assembly; if (globalType == null && modAsm != null) { var moduleDef = modAsm.FindModule(moduleRef.Name); if (moduleDef != null) { globalType = moduleDef.GlobalType; } } return(globalType); } var method = parent as MethodDef; if (method != null) { return(method.DeclaringType); } return(null); }
public MemberRef InstanceMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { return Method(true, name, declaringType, returnType, args); }
public MemberRef StaticMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { return(Method(false, name, declaringType, returnType, args)); }
public MemberRef StaticMethod(string name, IMemberRefParent declaringType, TypeSig returnType, params TypeSig[] args) { return Method(false, name, declaringType, returnType, args); }
/// <summary> /// Determines whether two member parents are considered equal according to their signature. /// </summary> /// <param name="parent1">The first member parent to compare.</param> /// <param name="parent2">The second member parent to compare.</param> /// <returns><c>True</c> if the parents are considered equal, <c>False</c> otherwise.</returns> public bool MatchParents(IMemberRefParent parent1, IMemberRefParent parent2) { if (parent1 == null && parent2 == null) return true; if (parent1 == null || parent2 == null) return false; var type = parent1 as ITypeDefOrRef; if (type != null) return MatchTypes(type, parent2 as ITypeDefOrRef); var moduleRef = parent1 as ModuleReference; if (moduleRef != null) return MatchModules(moduleRef, parent2 as ModuleReference); return false; }