GenericInstMethodSig ResolveGenericArgs(GenericInstMethodSig sig) { var gsig = new GenericInstMethodSig(); UpdateSigList(gsig.GenericArguments, sig.GenericArguments); return(gsig); }
void Add(GenericInstMethodSig gsig) { if (gsig == null) return; Add(gsig.ExtraData); Add(gsig.GenericArguments); }
void Add(GenericInstMethodSig sig) { if (sig == null) { return; } Add(sig.GenericArguments); }
GenericInstMethodSig CreateGenericInstMethodSig(MethodBase mb) { var genMethodArgs = mb.GetGenericArguments(); var gim = new GenericInstMethodSig(CallingConvention.GenericInst, (uint)genMethodArgs.Length); foreach (var gma in genMethodArgs) { gim.GenericArguments.Add(ImportAsTypeSig(gma)); } return(gim); }
/// <summary> /// Reads a <see cref="GenericInstMethodSig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="GenericInstMethodSig"/> instance</returns> GenericInstMethodSig ReadGenericInstMethod(CallingConvention callingConvention) { if (!reader.TryReadCompressedUInt32(out uint count)) { return(null); } var sig = new GenericInstMethodSig(callingConvention, count); var args = sig.GenericArguments; for (uint i = 0; i < count; i++) { args.Add(ReadType()); } return(sig); }
bool ContainsGenericParameterInternal(GenericInstMethodSig gim) { if (gim == null) { return(false); } if (!recursionCounter.Increment()) { return(false); } bool res = ContainsGenericParameter(gim.GenericArguments); recursionCounter.Decrement(); return(res); }
/// <summary> /// Imports a <see cref="GenericInstMethodSig"/> /// </summary> /// <param name="sig">The sig</param> /// <returns>The imported sig or <c>null</c> if input is invalid</returns> public GenericInstMethodSig Import(GenericInstMethodSig sig) { if (sig == null) { return(null); } if (!recursionCounter.Increment()) { return(null); } GenericInstMethodSig result = new GenericInstMethodSig(sig.GetCallingConvention(), (uint)sig.GenericArguments.Count); foreach (var l in sig.GenericArguments) { result.GenericArguments.Add(Import(l)); } recursionCounter.Decrement(); return(result); }
/// <summary> /// Checks whether <paramref name="gim"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="gim">Generic method signature</param> /// <returns><c>true</c> if <paramref name="gim"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(GenericInstMethodSig gim) { return(new TypeHelper().ContainsGenericParameterInternal(gim)); }
/// <summary> /// Constructor /// </summary> /// <param name="method">The generic method</param> /// <param name="sig">The instantiated method sig</param> public MethodSpecUser(IMethodDefOrRef method, GenericInstMethodSig sig) { this.method = method; this.instantiation = sig; }
void Add(GenericInstMethodSig sig) { if (sig == null) return; Add(sig.GenericArguments); }
bool ContainsGenericParameterInternal(GenericInstMethodSig gim) { if (gim == null) return false; if (!recursionCounter.Increment()) return false; bool res = ContainsGenericParameter(gim.GenericArguments); recursionCounter.Decrement(); return res; }
/// <summary> /// Checks whether <paramref name="gim"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="gim">Generic method signature</param> /// <returns><c>true</c> if <paramref name="gim"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(GenericInstMethodSig gim) { return new TypeHelper().ContainsGenericParameterInternal(gim); }
public static GenericInstMethodSig Create(GenericInstMethodSig sig, GenericInstSig git) { if (git == null) return sig; return Create(sig, git.GenericArguments); }
/// <summary> /// Constructor /// </summary> /// <param name="method">The generic method</param> /// <param name="sig">The instantiated method sig</param> public MethodSpecUser(IMethodDefOrRef method, GenericInstMethodSig sig) { this.method = method; this.instantiation = sig; }
List<IMethod> GetMethods(TypeDef declaringType, BabelMethodreference babelMethodRef) { var methods = new List<IMethod>(); var gis = babelMethodRef.DeclaringType as GenericInstSig; var gim = babelMethodRef.GenericArguments; foreach (var method in declaringType.Methods) { if (CompareMethod(GenericArgsSubstitutor.Create(method, gis, gim), babelMethodRef)) { if (!babelMethodRef.IsGenericMethod) methods.Add(memberRefConverter.Convert(method)); else { var gim2 = new GenericInstMethodSig(babelMethodRef.GenericArguments); var ms = module.UpdateRowId(new MethodSpecUser(memberRefConverter.Convert(method), gim2)); methods.Add(ms); } } } return methods; }
/// <summary> /// Gets the generic arguments /// </summary> /// <param name="sig">this</param> /// <returns>All generic arguments</returns> public static IList <TypeSig> GetGenericArguments(this GenericInstMethodSig sig) { return(sig == null ? new List <TypeSig>() : sig.GenericArguments); }
public static GenericInstMethodSig Create(GenericInstMethodSig sig, IList<TypeSig> genericArgs) { if (sig == null || genericArgs == null || genericArgs.Count == 0) return sig; return new GenericArgsSubstitutor(genericArgs).Create(sig); }
GenericInstMethodSig Create(GenericInstMethodSig sig) { var newSig = new GenericInstMethodSig(); for (int i = 0; i < sig.GenericArguments.Count; i++) newSig.GenericArguments.Add(Create2(sig.GenericArguments[i])); return updated ? newSig : sig; }
/// <summary> /// Gets the generic arguments /// </summary> /// <param name="sig">this</param> /// <returns>All generic arguments</returns> public static IList <TypeSig> GetGenericArguments(this GenericInstMethodSig sig) { return(sig == null?ThreadSafeListCreator.Create <TypeSig>() : sig.GenericArguments); }
void Hash(GenericInstMethodSig sig) { if (sig == null) return; hasher.Hash((byte)sig.GetCallingConvention()); foreach (var ga in sig.GetGenericArguments()) Hash(ga); }