private static bool MatchProperty(PropertyDef mCandidate, MethodBaseSig mCandidateSig, PropertyDef mProperty)
{
if (mCandidate == null || mCandidateSig == null || mProperty == null)
{
return(false);
}
if (mCandidate.Name != mProperty.Name)
{
return(false);
}
var accMeth = mCandidate.GetMethod ?? mCandidate.SetMethod;
if (accMeth != null && accMeth.HasOverrides)
{
return(false);
}
if (mProperty.PropertySig == null || mCandidateSig.GenParamCount != mProperty.PropertySig.GenParamCount)
{
return(false);
}
return(new SigComparer().Equals(mCandidateSig.Params, mProperty.PropertySig.Params));
}
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 sig)
{
if (sig is null)
{
return;
}
Add(sig.RetType);
Add(sig.Params);
Add(sig.ParamsAfterSentinel);
}
void add(MethodBaseSig sig)
{
if (sig == null)
{
return;
}
add(sig.RetType);
add(sig.Params);
add(sig.ParamsAfterSentinel);
}
void Add(MethodBaseSig msig)
{
if (msig == null)
{
return;
}
Add(msig.ExtraData);
Add(msig.RetType);
Add(msig.Params);
Add(msig.ParamsAfterSentinel);
}
public static IList <TypeSig> GetParameters(this MethodBaseSig methodSig)
{
if (methodSig.ParamsAfterSentinel != null)
{
return(methodSig.Params
.Concat(new TypeSig[] { new SentinelSig() })
.Concat(methodSig.ParamsAfterSentinel)
.ToList());
}
else
{
return(methodSig.Params);
}
}
/// <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 MethodBaseSig Resolve(MethodBaseSig methodSig, IList <TypeSig> typeGenArgs, IList <TypeSig> methodGenArgs)
{
if (methodSig == null)
{
return(null);
}
if ((typeGenArgs == null || typeGenArgs.Count == 0) && (methodGenArgs == null || methodGenArgs.Count == 0))
{
return(methodSig);
}
var resolver = new GenericArgumentResolver(typeGenArgs, methodGenArgs);
return(resolver.ResolveGenericArgs(methodSig));
}
MethodSig?ResolveGenericArgs(MethodBaseSig sig)
{
if (sig is 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 is null))
{
foreach (var p in old.ParamsAfterSentinel)
{
sig.ParamsAfterSentinel.Add(ResolveGenericArgs(p));
}
}
return(sig);
}
private void Write(MethodBaseSig sig)
{
if (sig == null)
{
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment())
{
helper.Error("Infinite recursion");
return;
}
writer.Write((byte)sig.GetCallingConvention());
if (sig.Generic)
{
WriteCompressedUInt32(sig.GenParamCount);
}
var numParams = (uint)sig.Params.Count;
if (sig.ParamsAfterSentinel != null)
{
numParams += (uint)sig.ParamsAfterSentinel.Count;
}
var count = WriteCompressedUInt32(numParams);
Write(sig.RetType);
for (uint i = 0; i < count && i < (uint)sig.Params.Count; i++)
{
Write(sig.Params[(int)i]);
}
if (sig.ParamsAfterSentinel != null && sig.ParamsAfterSentinel.Count > 0)
{
writer.Write((byte)ElementType.Sentinel);
for (uint i = 0, j = (uint)sig.Params.Count; i < (uint)sig.ParamsAfterSentinel.Count && j < count; i++, j++)
{
Write(sig.ParamsAfterSentinel[(int)i]);
}
}
recursionCounter.Decrement();
}
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);
}
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);
}
public MethodBaseSig Duplicate(MethodBaseSig metBaseSig)
{
switch (metBaseSig)
{
case PropertySig propSig:
return(new PropertySig(
propSig.HasThis,
Duplicate(propSig.RetType),
Duplicate(propSig.Params).ToArray()));
case MethodSig metSig:
return(new MethodSig(
metSig.CallingConvention,
metSig.GenParamCount,
Duplicate(metSig.RetType),
Duplicate(metSig.Params)));
default:
throw new ArgumentOutOfRangeException("Duplicate " + metBaseSig.GetType().Name);
}
}
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);
}
/// <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));
}
void WriteSignature(MethodBaseSig sig)
{
if (sig == null)
{
CallingConvention = 0;
ReturnType = null;
ParametersCreateTypeSigArray.TypeSigCollection.Clear();
GenericParameterCount.Value = 0;
SentinelCreateTypeSigArray.TypeSigCollection.Clear();
}
else
{
CallingConvention = sig.CallingConvention;
ReturnType = sig.RetType;
ParametersCreateTypeSigArray.TypeSigCollection.Clear();
ParametersCreateTypeSigArray.TypeSigCollection.AddRange(sig.Params);
GenericParameterCount.Value = sig.GenParamCount;
SentinelCreateTypeSigArray.TypeSigCollection.Clear();
if (sig.ParamsAfterSentinel != null)
{
SentinelCreateTypeSigArray.TypeSigCollection.AddRange(sig.ParamsAfterSentinel);
}
}
}
public static string SignatureName(this MethodBaseSig self)
{
Debug.Assert(self.ParamsAfterSentinel == null);
StringBuilder sb = new StringBuilder();
PrettyName(sb, self.RetType, false);
sb.Append(' ');
if (self.Generic)
{
sb.Append('<');
for (uint i = 0; i < self.GenParamCount; ++i)
{
if (i != 0)
{
sb.Append(',');
}
sb.AppendFormat("!!{0}", i);
}
sb.Append('>');
}
sb.Append('(');
for (int i = 0; i < self.Params.Count; ++i)
{
if (i != 0)
{
sb.Append(',');
}
PrettyName(sb, self.Params[i], false);
}
sb.Append(')');
return(sb.ToString());
}
private static bool MatchMethod(MethodDef mCandidate, MethodBaseSig mCandidateSig, MethodDef mMethod)
{
if (mCandidate == null || mCandidateSig == null || mMethod == null)
{
return(false);
}
if (mCandidate.Name != mMethod.Name)
{
return(false);
}
if (mCandidate.HasOverrides)
{
return(false);
}
if (mCandidate.IsSpecialName != mMethod.IsSpecialName)
{
return(false);
}
if (mCandidate.HasGenericParameters || mMethod.HasGenericParameters)
{
if (!mCandidate.HasGenericParameters || !mMethod.HasGenericParameters || mCandidate.GenericParameters.Count != mMethod.GenericParameters.Count)
{
return(false);
}
}
if (mMethod.MethodSig == null || mCandidateSig.Params.Count != mMethod.MethodSig.Params.Count)
{
return(false);
}
if (mCandidate.Parameters.Count != mMethod.Parameters.Count)
{
return(false);
}
for (int i = 0; i < mCandidate.Parameters.Count; i++)
{
var p1 = mCandidate.Parameters[i];
var p2 = mMethod.Parameters[i];
if (p1.IsHiddenThisParameter != p2.IsHiddenThisParameter)
{
return(false);
}
if (p1.IsHiddenThisParameter)
{
continue;
}
var pd1 = p1.ParamDef ?? new ParamDefUser();
var pd2 = p2.ParamDef ?? new ParamDefUser();
if (pd1.IsIn != pd2.IsIn || pd1.IsOut != pd2.IsOut)
{
return(false);
}
}
return(new SigComparer().Equals(mCandidateSig.Params, mMethod.MethodSig.Params));
}
/// <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) => new TypeHelper().ContainsGenericParameterInternal(methodSig);
private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext)
{
var genericArgs = typeContext.IsGenericInstanceType ? ((GenericInstSig)typeContext).GenericArguments : null;
return(GenericArgumentResolver.Resolve(method, genericArgs, null));
}
void Write(MethodBaseSig sig) {
if (sig == null) {
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
writer.Write((byte)sig.GetCallingConvention());
if (sig.Generic)
WriteCompressedUInt32(sig.GenParamCount);
uint numParams = (uint)sig.Params.Count;
if (sig.ParamsAfterSentinel != null)
numParams += (uint)sig.ParamsAfterSentinel.Count;
uint count = WriteCompressedUInt32(numParams);
Write(sig.RetType);
for (uint i = 0; i < count && i < (uint)sig.Params.Count; i++)
Write(sig.Params[(int)i]);
if (sig.ParamsAfterSentinel != null && sig.ParamsAfterSentinel.Count > 0) {
writer.Write((byte)ElementType.Sentinel);
for (uint i = 0, j = (uint)sig.Params.Count; i < (uint)sig.ParamsAfterSentinel.Count && j < count; i++, j++)
Write(sig.ParamsAfterSentinel[(int)i]);
}
recursionCounter.Decrement();
}
