public MemberRefOptions(MemberRef mr) { this.Class = mr.Class; this.Name = mr.Name; this.Signature = mr.Signature; this.CustomAttributes.AddRange(mr.CustomAttributes); }
void Add(CallingConventionSig sig) { if (sig == null) { return; } if (sig is FieldSig fs) { Add(fs); return; } if (sig is MethodBaseSig mbs) { Add(mbs); return; } if (sig is LocalSig ls) { Add(ls); return; } if (sig is GenericInstMethodSig gims) { Add(gims); return; } }
/// <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; }
void Add(CallingConventionSig sig) { if (sig is MethodBaseSig msig) { Add(msig); return; } if (sig is FieldSig fsig) { Add(fsig); return; } if (sig is LocalSig lsig) { Add(lsig); return; } if (sig is GenericInstMethodSig gsig) { Add(gsig); return; } Debug.Assert(sig is null); }
/// <summary> /// Checks whether <paramref name="callConv"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="callConv">Calling convention signature</param> /// <returns><c>true</c> if <paramref name="callConv"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(CallingConventionSig callConv) { var fs = callConv as FieldSig; if (fs != null) { return(ContainsGenericParameter(fs)); } var mbs = callConv as MethodBaseSig; if (mbs != null) { return(ContainsGenericParameter(mbs)); } var ls = callConv as LocalSig; if (ls != null) { return(ContainsGenericParameter(ls)); } var gim = callConv as GenericInstMethodSig; if (gim != null) { return(ContainsGenericParameter(gim)); } return(false); }
void Add(CallingConventionSig sig) { var msig = sig as MethodBaseSig; if (msig != null) { Add(msig); return; } var fsig = sig as FieldSig; if (fsig != null) { Add(fsig); return; } var lsig = sig as LocalSig; if (lsig != null) { Add(lsig); return; } var gsig = sig as GenericInstMethodSig; if (gsig != null) { Add(gsig); return; } Debug.Assert(sig == null); }
/// <summary> /// Constructor /// </summary> /// <param name="name">Method name</param> /// <param name="methodSig">Method sig</param> /// <param name="implFlags">Impl flags</param> /// <param name="flags">Flags</param> public MethodDefUser(UTF8String name, MethodSig methodSig, MethodImplAttributes implFlags, MethodAttributes flags) { this.name = name; this.signature = methodSig; this.implFlags = implFlags; this.flags = flags; this.parameters = new LazyList <ParamDef>(this); this.genericParams = new LazyList <GenericParam>(this); this.parameterList = new ParameterList(this); }
/// <summary> /// Checks whether <paramref name="callConv"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="callConv">Calling convention signature</param> /// <returns><c>true</c> if <paramref name="callConv"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(CallingConventionSig callConv) { var fs = callConv as FieldSig; if (fs != null) return ContainsGenericParameter(fs); var mbs = callConv as MethodBaseSig; if (mbs != null) return ContainsGenericParameter(mbs); var ls = callConv as LocalSig; if (ls != null) return ContainsGenericParameter(ls); var gim = callConv as GenericInstMethodSig; if (gim != null) return ContainsGenericParameter(gim); return false; }
CallingConventionSig ResolveGenericArgs(CallingConventionSig sig) { if (!recursionCounter.Increment()) { return(null); } CallingConventionSig result; MethodSig msig; FieldSig fsig; LocalSig lsig; PropertySig psig; GenericInstMethodSig gsig; if ((msig = sig as MethodSig) != null) { result = ResolveGenericArgs(msig); } else if ((fsig = sig as FieldSig) != null) { result = ResolveGenericArgs(fsig); } else if ((lsig = sig as LocalSig) != null) { result = ResolveGenericArgs(lsig); } else if ((psig = sig as PropertySig) != null) { result = ResolveGenericArgs(psig); } else if ((gsig = sig as GenericInstMethodSig) != null) { result = ResolveGenericArgs(gsig); } else { result = null; } recursionCounter.Decrement(); return(result); }
/// <summary> /// Imports a <see cref="CallingConventionSig"/> /// </summary> /// <param name="sig">The sig</param> /// <returns>The imported sig or <c>null</c> if input is invalid</returns> public CallingConventionSig Import(CallingConventionSig sig) { if (sig == null) { return(null); } if (!recursionCounter.Increment()) { return(null); } CallingConventionSig result; var sigType = sig.GetType(); if (sigType == typeof(MethodSig)) { result = Import((MethodSig)sig); } else if (sigType == typeof(FieldSig)) { result = Import((FieldSig)sig); } else if (sigType == typeof(GenericInstMethodSig)) { result = Import((GenericInstMethodSig)sig); } else if (sigType == typeof(PropertySig)) { result = Import((PropertySig)sig); } else if (sigType == typeof(LocalSig)) { result = Import((LocalSig)sig); } else { result = null; // Should never be reached } recursionCounter.Decrement(); return(result); }
private void Add(CallingConventionSig sig) { if (sig == null) { return; } var fs = sig as FieldSig; if (fs != null) { Add(fs); return; } var mbs = sig as MethodBaseSig; if (mbs != null) { Add(mbs); return; } var ls = sig as LocalSig; if (ls != null) { Add(ls); return; } var gims = sig as GenericInstMethodSig; if (gims != null) { Add(gims); return; } }
/// <summary> /// Checks whether <paramref name="callConv"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="callConv">Calling convention signature</param> /// <returns><c>true</c> if <paramref name="callConv"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(CallingConventionSig callConv) { if (callConv is FieldSig fs) { return(ContainsGenericParameter(fs)); } if (callConv is MethodBaseSig mbs) { return(ContainsGenericParameter(mbs)); } if (callConv is LocalSig ls) { return(ContainsGenericParameter(ls)); } if (callConv is GenericInstMethodSig gim) { return(ContainsGenericParameter(gim)); } return(false); }
/// <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(CallingConventionSig sig) { if (sig == null) return; var fs = sig as FieldSig; if (fs != null) { Add(fs); return; } var mbs = sig as MethodBaseSig; if (mbs != null) { Add(mbs); return; } var ls = sig as LocalSig; if (ls != null) { Add(ls); return; } var gims = sig as GenericInstMethodSig; if (gims != null) { Add(gims); return; } }
/// <summary> /// Gets the <see cref="CallingConventionSig.IsDefault"/> property /// </summary> /// <param name="sig">this</param> /// <returns>The type's <see cref="CallingConventionSig.IsDefault"/> property or /// <c>false</c> if input is<c>null</c></returns> public static bool GetIsDefault(this CallingConventionSig sig) { return(sig == null ? false : sig.IsDefault); }
/// <summary> /// Constructor /// </summary> /// <param name="localSig">A locals sig</param> public StandAloneSigUser(LocalSig localSig) { this.signature = localSig; }
/// <summary> /// Constructor /// </summary> /// <param name="signature">The method signature</param> public FnPtrSig(CallingConventionSig signature) { this.signature = signature; }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name</param> /// <param name="signature">Signature</param> /// <param name="flags">Flags</param> public FieldDefUser(UTF8String name, FieldSig signature, FieldAttributes flags) { this.name = name; this.signature = signature; this.flags = flags; }
/// <summary> /// Constructor /// </summary> /// <param name="methodSig">A method sig</param> public StandAloneSigUser(MethodSig methodSig) { this.signature = methodSig; }
public MethodSpecOptions(MethodSpec ms) { this.Method = ms.Method; this.Instantiation = ms.Instantiation; this.CustomAttributes.AddRange(ms.CustomAttributes); }
/// <summary> /// Returns the full name of a property /// </summary> /// <param name="declaringType">Declaring type full name or <c>null</c> if none</param> /// <param name="name">Name of property</param> /// <param name="propertySig">Property signature</param> /// <returns>Property full name</returns> public static string PropertyFullName(string declaringType, UTF8String name, CallingConventionSig propertySig) { return PropertyFullName(declaringType, name, propertySig, null); }
void CreatePropertyFullName(string declaringType, UTF8String name, CallingConventionSig propertySig) { CreateMethodFullName(declaringType, UTF8String.ToSystemString(name), propertySig as MethodBaseSig); }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name</param> /// <param name="sig">Property signature</param> /// <param name="flags">Flags</param> public PropertyDefUser(UTF8String name, PropertySig sig, PropertyAttributes flags) { this.name = name; this.type = sig; this.flags = flags; }
/// <summary> /// Returns the full name of a property /// </summary> /// <param name="declaringType">Declaring type full name or <c>null</c> if none</param> /// <param name="name">Name of property</param> /// <param name="propertySig">Property signature</param> /// <param name="typeGenArgs">Type generic arguments or <c>null</c> if none</param> /// <returns>Property full name</returns> public static string PropertyFullName(string declaringType, UTF8String name, CallingConventionSig propertySig, IList<TypeSig> typeGenArgs) { var fnc = new FullNameCreator(false, null); if (typeGenArgs != null) { fnc.genericArguments = new GenericArguments(); fnc.genericArguments.PushTypeArgs(typeGenArgs); } fnc.CreatePropertyFullName(declaringType, name, propertySig); return fnc.Result; }
/// <summary> /// Returns the full name of a property /// </summary> /// <param name="declaringType">Declaring type full name or <c>null</c> if none</param> /// <param name="name">Name of property</param> /// <param name="propertySig">Property signature</param> /// <param name="typeGenArgs">Type generic arguments or <c>null</c> if none</param> /// <param name="sb">String builder to use or null</param> /// <returns>Property full name</returns> public static string PropertyFullName(string declaringType, UTF8String name, CallingConventionSig propertySig, IList<TypeSig> typeGenArgs, StringBuilder sb) { return PropertyFullNameSB(declaringType, name, propertySig, typeGenArgs, sb).ToString(); }