/// <summary>Rewrite a CIL instruction if needed.</summary>
/// <param name="instruction">The current CIL instruction.</param>
/// <param name="cil">The CIL instruction processor.</param>
/// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
private bool RewriteInstruction(Instruction instruction, ILProcessor cil, Action <Instruction> replaceWith)
{
bool rewritten = false;
// field reference
FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
if (fieldRef != null)
{
rewritten |= this.RewriteTypeReference(fieldRef.DeclaringType, newType => fieldRef.DeclaringType = newType);
rewritten |= this.RewriteTypeReference(fieldRef.FieldType, newType => fieldRef.FieldType = newType);
}
// method reference
MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
if (methodRef != null)
{
this.RewriteMethodReference(methodRef);
}
// type reference
if (instruction.Operand is TypeReference typeRef)
{
rewritten |= this.RewriteTypeReference(typeRef, newType => replaceWith(cil.Create(instruction.OpCode, newType)));
}
// instruction itself
// (should be done after the above type rewrites to ensure valid types)
rewritten |= this.RewriteInstructionImpl(ref instruction, cil, newInstruction =>
{
rewritten = true;
cil.Replace(instruction, newInstruction);
instruction = newInstruction;
});
return(rewritten);
}
/// <summary>Get whether the field is a reference to the expected type and field.</summary>
/// <param name="instruction">The IL instruction.</param>
/// <param name="fullTypeName">The full type name containing the expected field.</param>
/// <param name="fieldName">The name of the expected field.</param>
public static bool IsFieldReferenceTo(Instruction instruction, string fullTypeName, string fieldName)
{
FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
return(RewriteHelper.IsFieldReferenceTo(fieldRef, fullTypeName, fieldName));
}
