public override void Process(ScannedMethod m, MethodSpec o)
{
foreach (var t in o.GenericInstMethodSig.GenericArguments)
{
m.RegisterGeneric(t);
}
}
public void AddAssociatedType(IMemberRef type, TypeSig associatedType)
{
if (associatedType.IsGenericInstanceType || associatedType.IsGenericTypeParameter)
{
return;
}
var si = GetScannedItem(type);
if (si == null)
{
switch (type)
{
case MethodDef m:
si = new ScannedMethod(m);
break;
case TypeDef t:
// si = new ScannedType(t); //types are currently Broken
break;
default:
throw new ArgumentException($"AddAssociatedType type must be either MethodDef or TypeDef", "type");
}
if (si == null)
{
return; //Should never happen in a working version. More for testing
}
scannedItems.Add(si);
}
si.AddAssociation(associatedType);
}
internal override void Process(ScannedMethod method, Instruction instruction, MemberRef operand)
{
Debug.Assert(method != null, $"{nameof(method)} != null");
Debug.Assert(instruction != null, $"{nameof(instruction)} != null");
Debug.Assert(operand != null, $"{nameof(operand)} != null");
// Scrambling member references only works for constructors without parameters currently.
if (instruction.OpCode != OpCodes.Newobj)
{
return;
}
if (operand.MethodSig.Params.Count > 0)
{
return;
}
TypeSig sig = null;
if (operand.Class is TypeRef typeRef)
{
sig = typeRef.ToTypeSig();
}
if (operand.Class is TypeSpec typeSpec)
{
sig = typeSpec.ToTypeSig();
}
if (sig != null)
{
method.RegisterGeneric(sig);
}
}
internal override void Process(ScannedMethod method, Instruction instruction, TypeRef operand)
{
Debug.Assert(method != null, $"{nameof(method)} != null");
Debug.Assert(instruction != null, $"{nameof(instruction)} != null");
Debug.Assert(operand != null, $"{nameof(operand)} != null");
method.RegisterGeneric(operand.ToTypeSig());
}
public void AddScannedItem(ScannedMethod m)
{
ScannedItem typescan;
if (GenericsMapper.TryGetValue(m.TargetMethod.DeclaringType.MDToken, out typescan))
{
m.GenericCount += typescan.GenericCount;
}
AddScannedItemGeneral(m);
}
internal override void Process(ScannedMethod method, Instruction instruction, MethodSpec operand)
{
Debug.Assert(method != null, $"{nameof(method)} != null");
Debug.Assert(instruction != null, $"{nameof(instruction)} != null");
Debug.Assert(operand != null, $"{nameof(operand)} != null");
foreach (var t in operand.GenericInstMethodSig.GenericArguments)
{
method.RegisterGeneric(t);
}
}
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodSpec operand)
{
ScannedMethod t = service.GetItem(method.MDToken) as ScannedMethod;
if (t != null)
{
var generics = operand.GenericInstMethodSig.GenericArguments.Select(x => t.ConvertToGenericIfAvalible(x));
operand.GenericInstMethodSig = new GenericInstMethodSig(generics.ToArray());
}
}
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodDef operand)
{
ScannedMethod tMethod = service.GetItem(operand.MDToken) as ScannedMethod;
ScannedItem currentMethod = service.GetItem(method.MDToken) as ScannedMethod;
if (tMethod != null)
{
var newspec = new MethodSpecUser(tMethod.TargetMethod, tMethod.CreateGenericMethodSig(currentMethod));
body[index].Operand = newspec;
}
}
public override void Process(ScannedMethod m, MethodDef o)
{
var sc = service.GetItem(o.MDToken) as ScannedMethod;
if (sc != null)
{
foreach (var regTypes in sc.TrueTypes)
{
m.RegisterGeneric(regTypes);
}
}
}
internal override void Process(ScannedMethod method, Instruction instruction, MethodDef operand)
{
Debug.Assert(method != null, $"{nameof(method)} != null");
Debug.Assert(instruction != null, $"{nameof(instruction)} != null");
Debug.Assert(operand != null, $"{nameof(operand)} != null");
var sc = Service.GetItem(operand);
if (sc?.IsScambled == true)
{
foreach (var regTypes in sc.TrueTypes)
{
method.RegisterGeneric(regTypes);
}
}
}
public override void Process(ScannedMethod m, MemberRef o)
{
TypeSig sig = null;
if (o.Class is TypeRef)
{
sig = (o.Class as TypeRef)?.ToTypeSig();
}
if (o.Class is TypeSpec)
{
sig = (o.Class as TypeSpec)?.ToTypeSig();
}
if (sig != null)
{
m.RegisterGeneric(sig);
}
}
public abstract void ProcessOperand(ScannedMethod m, object o);
public ContextAnalyzerFactory(ScannedMethod m)
{
targetMethod = m;
}
internal abstract void ProcessOperand(ScannedMethod method, Instruction instruction, object operand);
public override void Process(ScannedMethod m, TypeRef o)
{
m.RegisterGeneric(o.ToTypeSig());
}
internal ContextAnalyzerFactory(ScannedMethod method)
{
Debug.Assert(method != null, $"{nameof(method)} != null");
TargetMethod = method;
}
internal void AddScannedItem(ScannedMethod m) => AddScannedItemGeneral(m);
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MemberRef operand)
{
ScannedMethod current = service.GetItem(method.MDToken) as ScannedMethod;
if (operand.MethodSig.Params.Count > 0 || current == null || body[index].OpCode != OpCodes.Newobj)
{
return;
}
ModuleDef mod = method.Module;
var gettype = typeof(Type).GetMethod("GetTypeFromHandle");
var createInstance = typeof(Activator).GetMethod("CreateInstance", new Type[] { typeof(Type) });
var createInstanceArgs = typeof(Activator).GetMethod("CreateInstance", new Type[] { typeof(Type), typeof(object[]) });
TypeSig sig = null;
if (operand.Class is TypeRef)
{
sig = (operand.Class as TypeRef)?.ToTypeSig();
}
if (operand.Class is TypeSpec)
{
sig = (operand.Class as TypeSpec)?.ToTypeSig();
}
if (sig != null)
{
//ScannedItem t = service.GetItem(operand.MDToken);
//if (t != null) {
// sig = t.CreateGenericTypeSig(service.GetItem(method.DeclaringType.MDToken));
// }
var paramCount = operand.MethodSig.Params.Count;
var gen = current.GetGeneric(sig);
body[index].OpCode = OpCodes.Ldtoken;
TypeSpecUser newTypeSpec = null;
if (gen != null)
{
newTypeSpec = new TypeSpecUser(new GenericMVar(gen.Number));
}
else
{
newTypeSpec = new TypeSpecUser(sig);
}
body[index].Operand = newTypeSpec;
/*
* var genericCallSig = new GenericInstMethodSig( new TypeSig[] { current.ConvertToGenericIfAvalible(sig) });
* foreach(var param in operand.MethodSig.Params.Select(x => current.ConvertToGenericIfAvalible(x))) {
* genericCallSig.GenericArguments.Add(param);
* }
*
* // tgtMethod.GenericInstMethodSig = genericCallSig;
* var spec = new MethodSpecUser(tgtMethod, genericCallSig);
*
* body[index].OpCode = OpCodes.Call;
* body[index].Operand = tgtMethod;
*/
body.Insert(++index, Instruction.Create(OpCodes.Call, mod.Import(gettype)));
body.Insert(++index, Instruction.Create(OpCodes.Call, mod.Import(createInstance)));
}
}
internal override void ProcessOperand(ScannedMethod method, Instruction instruction, object operand) => Process(method, instruction, (T)operand);
internal abstract void Process(ScannedMethod method, Instruction instruction, T operand);