public bool MethodSigEquals(MethodBaseSig sig, MethodBase method) {
if (sig == null || method == null)
return false;
if (sig.HasThis != !method.IsStatic)
return false;
if (sig.Generic != method.IsGenericMethod)
return false;
if (sig.Generic) {
if (sig.GenParamCount != method.GetGenericArguments().Length)
return false;
}
if (method.IsMethodSpec())
method = method.Module.ResolveMethod(method.MetadataToken) ?? method;
var mps = method.GetParameters();
if (sig.Params.Count != mps.Length)
return false;
var minfo = method as MethodInfo;
if (minfo != null) {
if (!Equals(sig.RetType, minfo.ReturnType))
return false;
}
else {
if (sig.RetType.RemovePinnedAndModifiers().GetElementType() != ElementType.Void)
return false;
}
for (int i = 0; i < mps.Length; i++) {
if (!Equals(sig.Params[i], mps[i].ParameterType))
return false;
}
return true;
}
void Add(MethodBaseSig msig)
{
if (msig == null)
return;
Add(msig.ExtraData);
Add(msig.RetType);
Add(msig.Params);
Add(msig.ParamsAfterSentinel);
}
void Add(MethodBaseSig sig)
{
if (sig == null)
{
return;
}
Add(sig.RetType);
Add(sig.Params);
Add(sig.ParamsAfterSentinel);
}
public MethodBaseSig Create(MethodSigCreatorOptions options, MethodBaseSig origSig) {
var data = new MethodSigCreatorVM(options);
if (origSig is MethodSig)
data.MethodSig = (MethodSig)origSig;
else if (origSig is PropertySig)
data.PropertySig = (PropertySig)origSig;
var win = new MethodSigCreatorDlg();
win.DataContext = data;
win.Owner = ownerWindow ?? Application.Current.MainWindow;
if (win.ShowDialog() != true)
return null;
return data.MethodBaseSig;
}
MethodSig ResolveGenericArgs(MethodBaseSig sig)
{
if (sig == null)
{
return(null);
}
if (!recursionCounter.Increment())
{
return(null);
}
MethodSig result = ResolveGenericArgs(new MethodSig(sig.CallingConvention), sig);
recursionCounter.Decrement();
return(result);
}
MethodSig ResolveGenericArgs(MethodSig sig, MethodBaseSig old)
{
sig.RetType = ResolveGenericArgs(old.RetType);
foreach (var p in old.Params)
{
sig.Params.Add(ResolveGenericArgs(p));
}
sig.GenParamCount = old.GenParamCount;
if (sig.ParamsAfterSentinel != null)
{
foreach (var p in old.ParamsAfterSentinel)
{
sig.ParamsAfterSentinel.Add(ResolveGenericArgs(p));
}
}
return(sig);
}
bool ContainsGenericParameterInternal(MethodBaseSig mbs)
{
if (mbs == null)
{
return(false);
}
if (!recursionCounter.Increment())
{
return(false);
}
bool res = ContainsGenericParameterInternal(mbs.RetType) ||
ContainsGenericParameter(mbs.Params) ||
ContainsGenericParameter(mbs.ParamsAfterSentinel);
recursionCounter.Decrement();
return(res);
}
/// <summary>
/// Resolves the method signature with the specified generic arguments.
/// </summary>
/// <param name="methodSig">The method signature.</param>
/// <param name="typeGenArgs">The type generic arguments.</param>
/// <param name="methodGenArgs">The method generic arguments.</param>
/// <returns>Resolved method signature.</returns>
/// <exception cref="System.ArgumentException">No generic arguments to resolve.</exception>
public static MethodSig Resolve(MethodBaseSig methodSig, IList <TypeSig> typeGenArgs, IList <TypeSig> methodGenArgs)
{
if (methodSig == null)
{
return(null);
}
var resolver = new GenericArgumentResolver();
resolver.genericArguments = new GenericArguments();
resolver.recursionCounter = new RecursionCounter();
if (typeGenArgs != null)
{
resolver.genericArguments.PushTypeArgs(typeGenArgs);
}
if (methodGenArgs != null)
{
resolver.genericArguments.PushMethodArgs(methodGenArgs);
}
return(resolver.ResolveGenericArgs(methodSig));
}
private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext)
{
var genericArgs = typeContext is GenericInstSig ? ((GenericInstSig)typeContext).GenericArguments : null;
return GenericArgumentResolver.Resolve(method, genericArgs, null);
}
void Add(MethodBaseSig sig)
{
if (sig == null)
return;
Add(sig.RetType);
Add(sig.Params);
Add(sig.ParamsAfterSentinel);
}
bool ContainsGenericParameterInternal(MethodBaseSig mbs) {
if (mbs == null)
return false;
if (!recursionCounter.Increment())
return false;
bool res = ContainsGenericParameterInternal(mbs.RetType) ||
ContainsGenericParameter(mbs.Params) ||
ContainsGenericParameter(mbs.ParamsAfterSentinel);
recursionCounter.Decrement();
return res;
}
/// <summary>
/// Returns the full name of a property sig
/// </summary>
/// <param name="sig">Property sig</param>
/// <param name="sb">String builder to use or null</param>
/// <returns>Property sig full name</returns>
public static StringBuilder MethodBaseSigFullNameSB(MethodBaseSig sig, StringBuilder sb)
{
var fnc = new FullNameCreator(false, null, sb);
fnc.CreateMethodFullName(null, null, sig, null);
return fnc.sb ?? new StringBuilder();
}
/// <summary>
/// Gets the parameters after the sentinel
/// </summary>
/// <param name="sig">this</param>
/// <returns>Parameters after sentinel or <c>null</c> if none</returns>
public static IList <TypeSig> GetParamsAfterSentinel(this MethodBaseSig sig)
{
return(sig == null ? null : sig.ParamsAfterSentinel);
}
/// <summary>
/// Gets the parameter count
/// </summary>
/// <param name="sig">this</param>
/// <returns>Parameter count</returns>
public static int GetParamCount(this MethodBaseSig sig)
{
return(sig == null ? 0 : sig.Params.Count);
}
/// <summary>
/// Gets the return type
/// </summary>
/// <param name="sig">this</param>
/// <returns>Return type or <c>null</c> if none</returns>
public static TypeSig GetRetType(this MethodBaseSig sig)
{
return(sig == null ? null : sig.RetType);
}
/// <summary>
/// Gets the parameters
/// </summary>
/// <param name="sig">this</param>
/// <returns>The parameters</returns>
public static IList <TypeSig> GetParams(this MethodBaseSig sig)
{
return(sig == null ? new List <TypeSig>() : sig.Params);
}
/// <summary>
/// Returns the full name of a sig
/// </summary>
/// <param name="declType">Declaring type or null</param>
/// <param name="name">Name or null</param>
/// <param name="sig">Method sig</param>
/// <param name="gppMethod">Owner method or null</param>
/// <returns>Sig full name</returns>
public static string MethodBaseSigFullName(string declType, string name, MethodBaseSig sig, MethodDef gppMethod) {
var fnc = new FullNameCreator(false, null);
fnc.CreateMethodFullName(declType, name, sig, gppMethod);
return fnc.Result;
}
/// <summary>
/// Returns the full name of a property sig
/// </summary>
/// <param name="sig">Property sig</param>
/// <returns>Property sig full name</returns>
public static string MethodBaseSigFullName(MethodBaseSig sig) {
var fnc = new FullNameCreator(false, null);
fnc.CreateMethodFullName(null, null, sig, null);
return fnc.Result;
}
/// <summary>
/// Returns the full name of a sig
/// </summary>
/// <param name="declType">Declaring type or null</param>
/// <param name="name">Name or null</param>
/// <param name="sig">Method sig</param>
/// <param name="gppMethod">Owner method or null</param>
/// <param name="sb">String builder to use or null</param>
/// <returns>Sig full name</returns>
public static StringBuilder MethodBaseSigFullNameSB(string declType, string name, MethodBaseSig sig, MethodDef gppMethod, StringBuilder sb)
{
var fnc = new FullNameCreator(false, null, sb);
fnc.CreateMethodFullName(declType, name, sig, gppMethod);
return fnc.sb ?? new StringBuilder();
}
/// <summary>
/// Checks whether <paramref name="methodSig"/> contains a <see cref="GenericVar"/> or a
/// <see cref="GenericMVar"/>.
/// </summary>
/// <param name="methodSig">Method or property signature</param>
/// <returns><c>true</c> if <paramref name="methodSig"/> contains a <see cref="GenericVar"/>
/// or a <see cref="GenericMVar"/>.</returns>
public static bool ContainsGenericParameter(MethodBaseSig methodSig)
{
return(new TypeHelper().ContainsGenericParameterInternal(methodSig));
}
/// <summary>
/// Returns the full name of a property sig
/// </summary>
/// <param name="sig">Property sig</param>
/// <param name="sb">String builder to use or null</param>
/// <returns>Property sig full name</returns>
public static string MethodBaseSigFullName(MethodBaseSig sig, StringBuilder sb)
{
return MethodBaseSigFullNameSB(sig, sb).ToString();
}
private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext)
{
var args = new GenericArguments();
if (typeContext.IsGenericInstanceType)
args.PushTypeArgs(((GenericInstSig)typeContext).GenericArguments);
var retSig = new MethodSig(method.CallingConvention);
retSig.RetType = args.Resolve(method.RetType);
foreach (var param in method.Params)
retSig.Params.Add(args.Resolve(param));
return retSig;
}
/// <summary>
/// Gets the parameters
/// </summary>
/// <param name="sig">this</param>
/// <returns>The parameters</returns>
public static IList <TypeSig> GetParams(this MethodBaseSig sig)
{
return(sig == null?ThreadSafeListCreator.Create <TypeSig>() : sig.Params);
}
/// <summary>
/// Returns the full name of a property sig
/// </summary>
/// <param name="sig">Property sig</param>
/// <returns>Property sig full name</returns>
public static string MethodBaseSigFullName(MethodBaseSig sig)
{
return MethodBaseSigFullNameSB(sig, null).ToString();
}
/// <summary>
/// Gets the generic parameter count
/// </summary>
/// <param name="sig">this</param>
/// <returns>Generic parameter count</returns>
public static uint GetGenParamCount(this MethodBaseSig sig)
{
return(sig == null ? 0 : sig.GenParamCount);
}
/// <summary>
/// Checks whether <paramref name="methodSig"/> contains a <see cref="GenericVar"/> or a
/// <see cref="GenericMVar"/>.
/// </summary>
/// <param name="methodSig">Method or property signature</param>
/// <returns><c>true</c> if <paramref name="methodSig"/> contains a <see cref="GenericVar"/>
/// or a <see cref="GenericMVar"/>.</returns>
public static bool ContainsGenericParameter(MethodBaseSig methodSig) {
return new TypeHelper().ContainsGenericParameterInternal(methodSig);
}
void CreateMethodFullName(string declaringType, string name, MethodBaseSig methodSig) {
if (methodSig == null) {
sb.Append(NULLVALUE);
return;
}
CreateFullName(methodSig.RetType);
sb.Append(' ');
if (declaringType != null) {
sb.Append(declaringType);
sb.Append("::");
}
if (name != null)
sb.Append(name);
if (methodSig.Generic) {
sb.Append('<');
for (int i = 0; i < methodSig.GenParamCount; i++) {
if (i != 0)
sb.Append(',');
CreateFullName(new GenericMVar((uint)i));
}
sb.Append('>');
}
sb.Append('(');
int count = PrintMethodArgList(methodSig.Params, false, false);
PrintMethodArgList(methodSig.ParamsAfterSentinel, count > 0, true);
sb.Append(')');
}
/// <summary>
/// Returns the full name of a sig
/// </summary>
/// <param name="declType">Declaring type or null</param>
/// <param name="name">Name or null</param>
/// <param name="sig">Method sig</param>
/// <param name="gppMethod">Owner method or null</param>
/// <param name="sb">String builder to use or null</param>
/// <returns>Sig full name</returns>
public static string MethodBaseSigFullName(string declType, string name, MethodBaseSig sig, MethodDef gppMethod, StringBuilder sb)
{
return MethodBaseSigFullNameSB(declType, name, sig, gppMethod, sb).ToString();
}