public static VTableSignature FromMethod(IMethod method)
{
MethodSig sig = method.MethodSig;
TypeSig declType = method.DeclaringType.ToTypeSig();
if (declType is GenericInstSig)
{
sig = GenericArgumentResolver.Resolve(sig, ((GenericInstSig)declType).GenericArguments);
}
return(new VTableSignature(sig, method.Name));
}
static VTableSlot ResolveSlot(TypeDef openType, VTableSlot slot, IList <TypeSig> genArgs)
{
var newSig = GenericArgumentResolver.Resolve(slot.Signature.MethodSig, genArgs);
TypeSig newDecl = slot.MethodDefDeclType;
if (new SigComparer().Equals(newDecl, openType))
{
newDecl = new GenericInstSig((ClassOrValueTypeSig)openType.ToTypeSig(), genArgs.ToArray());
}
else
{
newDecl = GenericArgumentResolver.Resolve(newDecl, genArgs);
}
return(new VTableSlot(newDecl, slot.MethodDef, slot.DeclaringType, new VTableSignature(newSig, slot.Signature.Name), slot.Overrides));
}
static VTable ResolveGenericArgument(TypeDef openType, GenericInstSig genInst, VTable vTable)
{
Debug.Assert(new SigComparer().Equals(openType, vTable.Type));
var ret = new VTable(genInst);
foreach (VTableSlot slot in vTable.Slots)
{
ret.Slots.Add(ResolveSlot(openType, slot, genInst.GenericArguments));
}
foreach (var iface in vTable.InterfaceSlots)
{
ret.InterfaceSlots.Add(GenericArgumentResolver.Resolve(iface.Key, genInst.GenericArguments),
iface.Value.Select(slot => ResolveSlot(openType, slot, genInst.GenericArguments)).ToList());
}
return(ret);
}
/// <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>
/// <returns>Resolved method signature.</returns>
/// <exception cref="System.ArgumentException">No generic arguments to resolve.</exception>
public static MethodSig Resolve(MethodSig methodSig, IList <TypeSig> typeGenArgs)
{
if (typeGenArgs == null)
{
throw new ArgumentException("No generic arguments to resolve.");
}
var resolver = new GenericArgumentResolver();
resolver.genericArguments = new GenericArguments();
resolver.recursionCounter = new RecursionCounter();
if (typeGenArgs != null)
{
resolver.genericArguments.PushTypeArgs(typeGenArgs);
}
return(resolver.ResolveGenericArgs(methodSig));
}
