public static void Analyze(INameService service, ICollection <ModuleDefMD> modules, TypeDef type)
{
if (type.IsInterface)
{
return;
}
var vTbl = service.GetVTables()[type];
foreach (var ifaceVTbl in vTbl.InterfaceSlots.Values)
{
foreach (var slot in ifaceVTbl)
{
if (slot.Overrides == null)
{
continue;
}
Debug.Assert(slot.Overrides.MethodDef.DeclaringType.IsInterface);
// A method in base type can implements an interface method for a
// derived type. If the base type/interface is not in our control, we should
// not rename the methods.
bool baseUnderCtrl = modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool ifaceUnderCtrl = modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if ((!baseUnderCtrl && ifaceUnderCtrl) || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if (baseUnderCtrl && !ifaceUnderCtrl || !service.CanRename(slot.Overrides.MethodDef))
{
service.SetCanRename(slot.MethodDef, false);
}
}
}
}
public static void Analyze(INameService service, ICollection <ModuleDefMD> modules, TypeDef type)
{
if (type.IsInterface)
{
return;
}
var vTbl = service.GetVTables()[type];
foreach (var ifaceVTbl in vTbl.InterfaceSlots.Values)
{
foreach (var slot in ifaceVTbl)
{
if (slot.Overrides == null)
{
continue;
}
Debug.Assert(slot.Overrides.MethodDef.DeclaringType.IsInterface);
// A method in base type can implements an interface method for a
// derived type. If the base type/interface is not in our control, we should
// not rename the methods.
bool baseUnderCtrl = modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool interfaceUnderCtrl = modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if (!baseUnderCtrl && interfaceUnderCtrl || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if ((baseUnderCtrl && !interfaceUnderCtrl) || (!service.CanRename(slot.Overrides.MethodDef)))
{
service.SetCanRename(slot.MethodDef, false);
}
// Now it is possible that the method implementing the interface, belongs to the base class.
// If that happens the methods analyzing the methods will not pick up on this. We'll mark that
// case here.
if (!TypeEqualityComparer.Instance.Equals(slot.MethodDef.DeclaringType, type))
{
SetupOverwriteReferences(service, modules, slot, type);
//CreateOverrideReference(service, slot.MethodDef, slot.Overrides.MethodDef);
}
// For the case when method in base type implements an interface method for a derived type
// do not consider method parameters to make method name the same in base type, derived type and interface
var methodDef = slot.MethodDef;
var typeDef = type.BaseType?.ResolveTypeDef();
var baseMethod = typeDef?.FindMethod(methodDef.Name, methodDef.Signature as MethodSig);
if (baseMethod != null)
{
string unifiedName = service.GetNormalizedName(slot.Overrides.MethodDef);
service.SetNormalizedName(slot.MethodDef, unifiedName);
service.SetNormalizedName(baseMethod, unifiedName);
}
}
}
}
public static void Analyze(INameService service, ICollection <ModuleDefMD> modules, TypeDef type)
{
if (type.IsInterface)
{
return;
}
var vTbl = service.GetVTables()[type];
foreach (var ifaceVTbl in vTbl.InterfaceSlots.Values)
{
foreach (var slot in ifaceVTbl)
{
if (slot.Overrides == null)
{
continue;
}
Debug.Assert(slot.Overrides.MethodDef.DeclaringType.IsInterface);
// A method in base type can implements an interface method for a
// derived type. If the base type/interface is not in our control, we should
// not rename the methods.
bool baseUnderCtrl = modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool ifaceUnderCtrl = modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if ((!baseUnderCtrl && ifaceUnderCtrl) || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if (baseUnderCtrl && !ifaceUnderCtrl || !service.CanRename(slot.Overrides.MethodDef))
{
service.SetCanRename(slot.MethodDef, false);
}
// Now it is possible that the method implementing the interface, belongs to the base class.
// If that happens the methods analyzing the methods will not pick up on this. We'll mark that
// case here.
if (!TypeEqualityComparer.Instance.Equals(slot.MethodDef.DeclaringType, type))
{
SetupOverwriteReferences(service, modules, slot, type);
//CreateOverrideReference(service, slot.MethodDef, slot.Overrides.MethodDef);
}
}
}
}
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
VTable vTbl;
if (def is TypeDef)
{
var type = (TypeDef)def;
if (type.IsInterface)
{
return;
}
vTbl = service.GetVTables()[type];
foreach (var ifaceVTbl in vTbl.InterfaceSlots.Values)
{
foreach (var slot in ifaceVTbl)
{
if (slot.Overrides == null)
{
continue;
}
Debug.Assert(slot.Overrides.MethodDef.DeclaringType.IsInterface);
// A method in base type can implements an interface method for a
// derived type. If the base type/interface is not in our control, we should
// not rename the methods.
bool baseUnderCtrl = context.Modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool ifaceUnderCtrl = context.Modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if ((!baseUnderCtrl && ifaceUnderCtrl) || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if (baseUnderCtrl && !ifaceUnderCtrl || !service.CanRename(slot.Overrides.MethodDef))
{
service.SetCanRename(slot.MethodDef, false);
}
}
}
}
else if (def is MethodDef)
{
var method = (MethodDef)def;
if (!method.IsVirtual)
{
return;
}
vTbl = service.GetVTables()[method.DeclaringType];
VTableSignature sig = VTableSignature.FromMethod(method);
var slots = vTbl.FindSlots(method);
if (!method.IsAbstract)
{
foreach (var slot in slots)
{
if (slot.Overrides == null)
{
continue;
}
// Better on safe side, add references to both methods.
service.AddReference(method, new OverrideDirectiveReference(slot, slot.Overrides));
service.AddReference(slot.Overrides.MethodDef, new OverrideDirectiveReference(slot, slot.Overrides));
}
}
else
{
foreach (var slot in slots)
{
if (slot.Overrides == null)
{
continue;
}
service.SetCanRename(method, false);
service.SetCanRename(slot.Overrides.MethodDef, false);
}
}
}
}
// Token: 0x06000032 RID: 50 RVA: 0x000041C0 File Offset: 0x000023C0
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
if (def is TypeDef)
{
TypeDef type = (TypeDef)def;
if (type.IsInterface)
{
return;
}
VTable vTbl = service.GetVTables()[type];
using (IEnumerator <IList <VTableSlot> > enumerator = vTbl.InterfaceSlots.Values.GetEnumerator())
{
while (enumerator.MoveNext())
{
IList <VTableSlot> ifaceVTbl = enumerator.Current;
foreach (VTableSlot slot in ifaceVTbl)
{
if (slot.Overrides != null)
{
bool baseUnderCtrl = context.Modules.Contains(slot.MethodDef.DeclaringType.Module as ModuleDefMD);
bool ifaceUnderCtrl = context.Modules.Contains(slot.Overrides.MethodDef.DeclaringType.Module as ModuleDefMD);
if ((!baseUnderCtrl && ifaceUnderCtrl) || !service.CanRename(slot.MethodDef))
{
service.SetCanRename(slot.Overrides.MethodDef, false);
}
else if ((baseUnderCtrl && !ifaceUnderCtrl) || !service.CanRename(slot.Overrides.MethodDef))
{
service.SetCanRename(slot.MethodDef, false);
}
}
}
}
return;
}
}
if (def is MethodDef)
{
MethodDef method = (MethodDef)def;
if (!method.IsVirtual)
{
return;
}
VTable vTbl = service.GetVTables()[method.DeclaringType];
VTableSignature.FromMethod(method);
IEnumerable <VTableSlot> slots = vTbl.FindSlots(method);
if (!method.IsAbstract)
{
using (IEnumerator <VTableSlot> enumerator3 = slots.GetEnumerator())
{
while (enumerator3.MoveNext())
{
VTableSlot slot2 = enumerator3.Current;
if (slot2.Overrides != null)
{
service.AddReference <MethodDef>(method, new OverrideDirectiveReference(slot2, slot2.Overrides));
service.AddReference <MethodDef>(slot2.Overrides.MethodDef, new OverrideDirectiveReference(slot2, slot2.Overrides));
}
}
return;
}
}
foreach (VTableSlot slot3 in slots)
{
if (slot3.Overrides != null)
{
service.SetCanRename(method, false);
service.SetCanRename(slot3.Overrides.MethodDef, false);
}
}
}
}
