/// <summary>
/// Weaves the specified module definition.
/// </summary>
/// <param name="moduleDefinition">The module definition.</param>
public bool Weave(ModuleDefMD moduleDefinition)
{
var auditTimer = new AuditTimer();
try
{
// sanity check
auditTimer.NewZone("Types import");
// context
var context = CreateWeavingContext(moduleDefinition);
if (context.AdviceInterfaceType == null)
{
Logging.WriteWarning("IAdvice interface not found here (not referenced means not used), exiting");
return(false);
}
// runtime check
auditTimer.NewZone("Runtime check");
var targetFramework = GetTargetFramework(moduleDefinition);
InjectAsPrivate = targetFramework.Silverlight == null && targetFramework.WindowsPhone == null;
// weave methods (they can be property-related, too)
auditTimer.NewZone("Weavable methods detection");
Func <MarkedNode, bool> isWeavable = n => IsWeavable(n) && !IsFromComputerGeneratedType(n);
var weavingAdvicesMethods = GetMarkedMethods(moduleDefinition, context.WeavingAdviceInterfaceType, context).Where(isWeavable).ToArray();
var weavableMethods = GetMarkedMethods(moduleDefinition, context.AdviceInterfaceType, context).Where(isWeavable).ToArray();
auditTimer.NewZone("Abstract targets");
var generatedFieldsToBeRemoved = new List <FieldDef>();
var methodsWithAbstractTarget = weavableMethods.Where(m => m.AbstractTarget).ToArray();
if (methodsWithAbstractTarget.Length > 0)
{
generatedFieldsToBeRemoved.AddRange(GetRemovableFields(methodsWithAbstractTarget, context));
foreach (var fieldReference in generatedFieldsToBeRemoved)
{
Logging.WriteDebug("Field {0} to be removed", fieldReference.FullName);
}
}
auditTimer.NewZone("Methods weaving advice");
weavingAdvicesMethods.ForAll(i => RunWeavingAdvices(i, context));
auditTimer.NewZone("Methods weaving");
weavableMethods.ForAll(m => WeaveMethod(moduleDefinition, m, context));
auditTimer.NewZone("Weavable interfaces detection");
var weavableInterfaces = GetAdviceHandledInterfaces(moduleDefinition).ToArray();
auditTimer.NewZone("Interface methods weaving");
weavableInterfaces.ForAll(i => WeaveInterface(moduleDefinition, i, context));
// and then, the info advices
auditTimer.NewZone("Info advices weaving");
var infoAdviceInterface = TypeResolver.Resolve(moduleDefinition, typeof(IInfoAdvice));
moduleDefinition.GetTypes().ForAll(t => WeaveInfoAdvices(moduleDefinition, t, infoAdviceInterface, context));
auditTimer.NewZone("Abstract targets cleanup");
foreach (var generatedFieldToBeRemoved in generatedFieldsToBeRemoved)
{
generatedFieldToBeRemoved.DeclaringType.Fields.Remove(generatedFieldToBeRemoved);
}
auditTimer.LastZone();
var report = auditTimer.GetReport();
var maxLength = report.Keys.Max(k => k.Length);
Logging.WriteDebug("--- Timings --------------------------");
foreach (var reportPart in report)
{
Logging.WriteDebug("{0} : {1}ms", reportPart.Key.PadRight(maxLength), (int)reportPart.Value.TotalMilliseconds);
}
Logging.WriteDebug("--------------------------------------");
Logging.Write("MrAdvice {3} weaved module '{0}' (targeting framework {2}) in {1}ms",
moduleDefinition.Assembly.FullName, (int)report.Sum(r => r.Value.TotalMilliseconds), targetFramework.ToString(), Product.Version);
return(true);
}
catch (Exception e)
{
Logging.WriteError("Internal error during {0}: {1}", auditTimer.CurrentZoneName, e);
Logging.WriteError("Please complain, whine, cry, yell at https://github.com/ArxOne/MrAdvice/issues/new");
return(false);
}
}
/// <summary>
/// Gets the advice handled interfaces.
/// This is done by analyzing calls in all methods from module
/// </summary>
/// <param name="moduleDefinition">The module definition.</param>
/// <returns></returns>
private IEnumerable <TypeDef> GetAdviceHandledInterfaces(ModuleDef moduleDefinition)
{
// the first method to look for in the final AdviceExtensions.Handle<>() method
var adviceExtensionsType = TypeResolver.Resolve(moduleDefinition, typeof(AdviceExtensions));
var adviceHandleMethod = adviceExtensionsType.Methods.Single(m => m.IsPublic && m.HasGenericParameters && m.Name == nameof(AdviceExtensions.Handle));
var methodsSearched = new HashSet <MethodDef>(new MethodReferenceComparer())
{
adviceHandleMethod
};
var foundHandledInterfaces = new HashSet <ITypeDefOrRef>(new TypeReferenceComparer());
var methodsToSearch = new List <Tuple <MethodDef, int> > {
Tuple.Create(adviceHandleMethod, 0)
};
while (methodsToSearch.Count > 0)
{
var methodToSearch = methodsToSearch[0];
methodsToSearch.RemoveAt(0);
foreach (var t in GetAdviceHandledInterfaces(moduleDefinition, methodToSearch.Item1, methodToSearch.Item2))
{
// if the supposed interface type itself is a generic parameter
// this means that the calling method (Item2) is itself a generic parameter
// and we have to lookup for calls to this method
if (t.Item1.ContainsGenericParameter)
{
if (!methodsSearched.Contains(t.Item2))
{
// ReSharper disable once AccessToForEachVariableInClosure
var parameterIndex = t.Item2.GenericParameters.IndexOf(p => p.Name == t.Item1.TypeName);
methodsSearched.Add(t.Item2);
methodsToSearch.Add(Tuple.Create(t.Item2, parameterIndex));
Logging.WriteDebug("Now looking for references to '{0} [{1}]'", methodToSearch.Item1.ToString(), parameterIndex);
}
}
// only interfaces are processed by now
else
{
var interfaceDef = t.Item1 as TypeDef;
if (interfaceDef == null)
{
if (t.Item1 is TypeRef interfaceRef)
{
interfaceDef = TypeResolver.Resolve(interfaceRef);
}
}
if (interfaceDef == null)
{
Logging.WriteError("Can not identify {0} as valid weavable interface. If you feel this is unfair --> https://github.com/ArxOne/MrAdvice/issues/new", t.Item1.ToString());
continue;
}
if (interfaceDef.IsInterface)
{
// otherwise, this is a direct call, keep the injected interface name
if (!foundHandledInterfaces.Contains(t.Item1))
{
foundHandledInterfaces.Add(t.Item1);
yield return(interfaceDef);
}
}
else
{
Logging.WriteError("Only interfaces can be weaved with Handle<>() extension method and {0} it not an interface (but I'm glad you asked)", interfaceDef.FullName);
}
}
}
}
}
/// <summary>
/// Writes the pointcut body.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="innerMethod">The inner method.</param>
/// <param name="abstractedTarget">if set to <c>true</c> [abstracted target].</param>
/// <exception cref="System.InvalidOperationException">
/// </exception>
private void WritePointcutBody(MethodDefinition method, MethodDefinition innerMethod, bool abstractedTarget)
{
var moduleDefinition = method.Module;
// now empty the old one and make it call the inner method...
if (method.Body == null)
{
method.Body = new MethodBody(method);
}
method.Body.InitLocals = true;
method.Body.Instructions.Clear();
method.Body.Variables.Clear();
method.Body.ExceptionHandlers.Clear();
var instructions = new Instructions(method.Body.Instructions, method.Module);
var isStatic = method.Attributes.HasFlag(MethodAttributes.Static);
// parameters
VariableDefinition parametersVariable = null;
if (method.Parameters.Count > 0)
{
parametersVariable = new VariableDefinition("parameters", moduleDefinition.SafeImport(typeof(object[])));
method.Body.Variables.Add(parametersVariable);
instructions.EmitLdc(method.Parameters.Count);
instructions.Emit(OpCodes.Newarr, moduleDefinition.SafeImport(typeof(object)));
instructions.EmitStloc(parametersVariable);
// setups parameters array
for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; parameterIndex++)
{
var parameter = method.Parameters[parameterIndex];
// we don't care about output parameters
if (!parameter.IsOut)
{
instructions.EmitLdloc(parametersVariable); // array
instructions.EmitLdc(parameterIndex); // array index
instructions.EmitLdarg(parameter); // loads given parameter...
var parameterType = parameter.ParameterType;
if (parameter.ParameterType.IsByReference) // ...if ref, loads it as referenced value
{
parameterType = parameter.ParameterType.GetElementType();
instructions.EmitLdind(parameterType);
}
instructions.EmitBoxIfNecessary(parameterType); // ... and boxes it
instructions.Emit(OpCodes.Stelem_Ref);
}
}
}
// if method has generic parameters, we also pass them to Proceed method
VariableDefinition genericParametersVariable = null;
// on static methods from genetic type, we also record the generic parameters type
//var typeGenericParametersCount = isStatic ? method.DeclaringType.GenericParameters.Count : 0;
var typeGenericParametersCount = method.DeclaringType.GenericParameters.Count;
if (typeGenericParametersCount > 0 || method.HasGenericParameters)
{
//IL_0001: ldtoken !!T
//IL_0006: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
genericParametersVariable = new VariableDefinition("genericParameters", moduleDefinition.SafeImport(typeof(Type[])));
method.Body.Variables.Add(genericParametersVariable);
instructions.EmitLdc(typeGenericParametersCount + method.GenericParameters.Count);
instructions.Emit(OpCodes.Newarr, moduleDefinition.SafeImport(typeof(Type)));
instructions.EmitStloc(genericParametersVariable);
var genericParameters = new List <GenericParameter>();
for (int typeGenericParameterIndex = 0; typeGenericParameterIndex < typeGenericParametersCount; typeGenericParameterIndex++)
{
genericParameters.Add(method.DeclaringType.GenericParameters[typeGenericParameterIndex]);
}
genericParameters.AddRange(method.GenericParameters);
for (int genericParameterIndex = 0; genericParameterIndex < genericParameters.Count; genericParameterIndex++)
{
instructions.EmitLdloc(genericParametersVariable); // array
instructions.EmitLdc(genericParameterIndex); // array index
instructions.Emit(OpCodes.Ldtoken, genericParameters[genericParameterIndex]);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => Type.GetTypeFromHandle(new RuntimeTypeHandle())));
instructions.Emit(OpCodes.Stelem_Ref);
}
}
// null or instance
instructions.Emit(isStatic ? OpCodes.Ldnull : OpCodes.Ldarg_0);
// to fix peverify 0x80131854
if (!isStatic && method.IsConstructor)
{
instructions.Emit(OpCodes.Castclass, typeof(object));
}
// parameters
if (parametersVariable != null)
{
instructions.EmitLdloc(parametersVariable);
}
else
{
instructions.Emit(OpCodes.Ldnull);
}
// methods...
// ... target
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetCurrentMethod()));
// ... inner... If provided
if (innerMethod != null)
{
// if type is generic, this is a bit more complex, because we need to pass the type
if (method.DeclaringType.HasGenericParameters)
{
// we want to reuse the MethodBase.GetCurrentMethod() result
// so it is stored into a variable, whose property DeclaringType is invoked later
var currentMethodVariable = new VariableDefinition("currentMethod", moduleDefinition.SafeImport(typeof(MethodBase)));
method.Body.Variables.Add(currentMethodVariable);
instructions.EmitStloc(currentMethodVariable);
instructions.EmitLdloc(currentMethodVariable);
instructions.Emit(OpCodes.Ldtoken, innerMethod);
instructions.EmitLdloc(currentMethodVariable);
instructions.Emit(OpCodes.Callvirt, ReflectionUtility.GetMethodInfo((Type t) => t.DeclaringType));
instructions.Emit(OpCodes.Callvirt, ReflectionUtility.GetMethodInfo((Type t) => t.TypeHandle));
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetMethodFromHandle(new RuntimeMethodHandle(), new RuntimeTypeHandle())));
}
else
{
instructions.Emit(OpCodes.Ldtoken, innerMethod);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetMethodFromHandle(new RuntimeMethodHandle())));
}
}
else
{
instructions.Emit(OpCodes.Ldnull);
}
// abstracted target
instructions.Emit(abstractedTarget ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
if (genericParametersVariable != null)
{
instructions.EmitLdloc(genericParametersVariable);
}
else
{
instructions.Emit(OpCodes.Ldnull);
}
// invoke the method
var invocationType = TypeResolver.Resolve(moduleDefinition, typeof(Invocation));
if (invocationType == null)
{
throw new InvalidOperationException();
}
var proceedMethodReference = invocationType.GetMethods().SingleOrDefault(m => m.IsStatic && m.Name == nameof(Invocation.ProceedAdvice));
if (proceedMethodReference == null)
{
throw new InvalidOperationException();
}
var proceedMethod = moduleDefinition.SafeImport(proceedMethodReference);
instructions.Emit(OpCodes.Call, proceedMethod);
// get return value
if (!method.ReturnType.SafeEquivalent(moduleDefinition.SafeImport(typeof(void))))
{
instructions.EmitUnboxOrCastIfNecessary(method.ReturnType);
}
else
{
instructions.Emit(OpCodes.Pop); // if no return type, ignore Proceed() result
}
// loads back out/ref parameters
for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; parameterIndex++)
{
var parameter = method.Parameters[parameterIndex];
if (parameter.ParameterType.IsByReference)
{
instructions.EmitLdarg(parameter); // loads given parameter (it is a ref)
instructions.EmitLdloc(parametersVariable); // array
instructions.EmitLdc(parameterIndex); // array index
instructions.Emit(OpCodes.Ldelem_Ref); // now we have boxed out/ref value
var parameterElementType = parameter.ParameterType.GetElementType();
if (parameterElementType.HasGenericParameters) // a generic type requires the correct inner type
{
var referenceParameterType = (ByReferenceType)parameter.ParameterType;
parameterElementType = (GenericInstanceType)referenceParameterType.ElementType;
}
instructions.EmitUnboxOrCastIfNecessary(parameterElementType);
instructions.EmitStind(parameterElementType); // result is stored in ref parameter
}
}
// and return
instructions.Emit(OpCodes.Ret);
}
/// <summary>
/// Weaves the interface.
/// What we do here is:
/// - creating a class (wich is named after the interface name)
/// - this class implements all interface members
/// - all members invoke Invocation.ProcessInterfaceMethod
/// </summary>
/// <param name="moduleDefinition">The module definition.</param>
/// <param name="interfaceType">Type of the interface.</param>
private void WeaveInterface(ModuleDefinition moduleDefinition, TypeReference interfaceType)
{
Logger.WriteDebug("Weaving interface '{0}'", interfaceType.FullName);
TypeDefinition implementationType;
TypeDefinition advisedInterfaceType;
TypeDefinition interfaceTypeDefinition;
lock (moduleDefinition)
{
// ensure we're creating the interface only once
var implementationTypeName = GetImplementationTypeName(interfaceType.Name);
var implementationTypeNamespace = interfaceType.Namespace;
if (moduleDefinition.GetTypes().Any(t => t.Namespace == implementationTypeNamespace && t.Name == implementationTypeName))
{
return;
}
// now, create the implementation type
interfaceTypeDefinition = interfaceType.Resolve();
var typeAttributes = (InjectAsPrivate ? TypeAttributes.NotPublic : TypeAttributes.Public) | TypeAttributes.Class | TypeAttributes.BeforeFieldInit;
advisedInterfaceType = TypeResolver.Resolve(moduleDefinition, typeof(AdvisedInterface));
var advisedInterfaceTypeReference = moduleDefinition.SafeImport(advisedInterfaceType);
implementationType = new TypeDefinition(implementationTypeNamespace, implementationTypeName, typeAttributes, advisedInterfaceTypeReference);
lock (moduleDefinition)
moduleDefinition.Types.Add(implementationType);
}
implementationType.Interfaces.Add(interfaceType);
// create empty .ctor. This .NET mofo wants it!
var baseEmptyConstructor = moduleDefinition.SafeImport(advisedInterfaceType.Resolve().GetConstructors().Single());
const MethodAttributes ctorAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
var method = new MethodDefinition(".ctor", ctorAttributes, moduleDefinition.TypeSystem.Void);
method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
method.Body.Instructions.Add(Instruction.Create(OpCodes.Call, baseEmptyConstructor));
method.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
implementationType.Methods.Add(method);
// create implementation methods
foreach (var interfaceMethod in interfaceTypeDefinition.GetMethods().Where(m => !m.IsSpecialName))
{
WeaveInterfaceMethod(interfaceMethod, implementationType, true);
}
// create implementation properties
foreach (var interfaceProperty in interfaceTypeDefinition.Properties)
{
var implementationProperty = new PropertyDefinition(interfaceProperty.Name, PropertyAttributes.None, interfaceProperty.PropertyType);
implementationType.Properties.Add(implementationProperty);
if (interfaceProperty.GetMethod != null)
{
implementationProperty.GetMethod = WeaveInterfaceMethod(interfaceProperty.GetMethod, implementationType, InjectAsPrivate);
}
if (interfaceProperty.SetMethod != null)
{
implementationProperty.SetMethod = WeaveInterfaceMethod(interfaceProperty.SetMethod, implementationType, InjectAsPrivate);
}
}
// create implementation events
foreach (var interfaceEvent in interfaceTypeDefinition.Events)
{
var implementationEvent = new EventDefinition(interfaceEvent.Name, EventAttributes.None, moduleDefinition.SafeImport(interfaceEvent.EventType));
implementationType.Events.Add(implementationEvent);
if (interfaceEvent.AddMethod != null)
{
implementationEvent.AddMethod = WeaveInterfaceMethod(interfaceEvent.AddMethod, implementationType, InjectAsPrivate);
}
if (interfaceEvent.RemoveMethod != null)
{
implementationEvent.RemoveMethod = WeaveInterfaceMethod(interfaceEvent.RemoveMethod, implementationType, InjectAsPrivate);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WeaverMethodWeavingContext" /> class.
/// </summary>
/// <param name="typeDefinition">The type definition (type being built).</param>
/// <param name="type">The type (original type).</param>
/// <param name="targetMethodName">Name of the target method.</param>
/// <param name="context">The context.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="logging">The logging.</param>
public WeaverMethodWeavingContext(TypeDef typeDefinition, Type type, string targetMethodName, WeavingContext context, TypeResolver typeResolver, ILogging logging)
: base(type, targetMethodName)
{
_typeDefinition = typeDefinition;
_context = context;
_typeResolver = typeResolver;
_logging = logging;
}
