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;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localSig">A locals sig</param>
public StandAloneSigUser(LocalSig localSig)
{
this.signature = localSig;
}
public MethodSpecOptions(MethodSpec ms)
{
this.Method = ms.Method;
this.Instantiation = ms.Instantiation;
this.CustomAttributes.AddRange(ms.CustomAttributes);
}
/// <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;
}
/// <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;
}
/// <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);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="methodSig">A method sig</param>
public StandAloneSigUser(MethodSig methodSig) {
this.signature = methodSig;
}
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>
/// 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>
/// 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>
/// 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="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>
/// <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();
}
