public EmitMethodInvocationExpression(EmitMethod method, params EmitExpression[] arguments)
{
if (!method.IsStatic)
throw new Exception("Non-static method requires a target.");
Method = method;
Arguments.AddRange(arguments);
}
public EmitMethodInvocationExpression(EmitExpression target, EmitMethod method, params EmitExpression[] arguments)
{
if (method.IsStatic && target != null)
throw new Exception("Static method cannot have a target");
Target = target;
Method = method;
Arguments.AddRange(arguments);
}
public EmitMethodInvocationExpression(EmitMethod method, params EmitExpression[] arguments)
{
if (!method.IsStatic)
{
throw new Exception("Non-static method requires a target.");
}
Method = method;
Arguments.AddRange(arguments);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMemeber, IEmitterType targetMember)
{
Type mapperType = typeof(Mapper);
MethodInfo mapMethod = mapperType.GetMethod(Mapper.MapMethodName, BindingFlags.Instance | BindingFlags.Public);
FieldInfo mappersField = mapperType.GetField(Mapper.MappersFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
IEmitterType mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
IEmitterType mapper = EmitArray.Load(mappers, Id);
IEmitterType result = EmitMethod.Call(mapMethod, mapper, sourceMemeber, targetMember);
return(result);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMember, IEmitterType targetMember)
{
var mapperType = typeof(Mapper);
var mapMethod = mapperType.GetMethod(Mapper.MAP_METHOD_NAME, BindingFlags.Instance | BindingFlags.Public);
var mappersField = mapperType.GetField(Mapper.MAPPERS_FIELD_NAME, BindingFlags.Instance | BindingFlags.NonPublic);
var mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
var mapper = EmitArray.Load(mappers, Id);
var result = EmitMethod.Call(mapMethod, mapper, sourceMember, targetMember);
return(result);
}
public EmitMethodInvocationExpression(EmitExpression target, EmitMethod method, params EmitExpression[] arguments)
{
if (method.IsStatic && target != null)
{
throw new Exception("Static method cannot have a target");
}
Target = target;
Method = method;
Arguments.AddRange(arguments);
}
public void InvokeStaticMethod()
{
var method = CreateMethod(block =>
{
EmitMethod methodInfo = typeof(StaticMethodClass).GetMethod("Mirror");
block.Return(methodInfo.Call("foo"));
});
var result = (string)method.Invoke(null, null);
Assert.AreEqual("foo", result);
}
public void BooleanOrShortCircuitsFalse()
{
ShortCircuitsData.Reset();
EmitMethod returnTrue = typeof(ShortCircuitsData).GetMethod("ReturnTrue");
EmitMethod returnFalse = typeof(ShortCircuitsData).GetMethod("ReturnFalse");
var method = CreateMethod(block => block.Return(returnFalse.Call().BooleanOr(returnTrue.Call())));
var result = (bool)method.Invoke(null, null);
Assert.AreEqual(1, ShortCircuitsData.NumberOfCallsToReturnTrue);
Assert.AreEqual(1, ShortCircuitsData.NumberOfCallsToReturnFalse);
Assert.IsTrue(result);
}
public void PostDecrement()
{
EmitMethod tupleMethod = typeof(Tuple).GetMethods().Where(x => x.GetGenericArguments().Length == 2).Single().MakeGenericMethod(typeof(int), typeof(int));
var method = CreateMethod(block =>
{
var variable = block.Declare(typeof(int));
block.Express(variable.Assign(2));
block.Return(tupleMethod.Call(variable.PostDecrement(), variable));
});
var result = (Tuple <int, int>)method.Invoke(null, null);
Assert.AreEqual(2, result.Item1);
Assert.AreEqual(1, result.Item2);
}
private void EmitEnumerableToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
Type sourceItemType = typePair.Source.GetCollectionItemType();
Type targetItemType = typePair.Target.GetCollectionItemType();
EmitConvertItem(typeBuilder, new TypePair(sourceItemType, targetItemType));
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, targetItemType);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitDictionaryToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
KeyValuePair <Type, Type> sourceTypes = typePair.Source.GetDictionaryItemTypes();
KeyValuePair <Type, Type> targetTypes = typePair.Target.GetDictionaryItemTypes();
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Key, targetTypes.Key), ConvertItemKeyMethod);
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Value, targetTypes.Value));
var arguments = new[] { sourceTypes.Key, sourceTypes.Value, targetTypes.Key, targetTypes.Value };
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, arguments);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitEnumerableToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
TypePair collectionItemTypePair,
string methodName,
string templateMethodName)
{
var methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
EmitConvertItem(typeBuilder, collectionItemTypePair);
var methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target);
var returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
public MemberInfo VisitMethod(EmitMethod method, TypeBuilder parent)
{
var methodBuilder = parent.DefineMethod(
method.Name,
ReflectionMethodAttributes.ToMethodAttributes(method.Visibility, method.IsAbstract, method.IsSealed, method.IsVirtual, false, method.IsStatic),
method.ReturnType,
method.Parameters.Select(x => (Type)x.ParameterType).ToArray());
var emitMethodBuilder = (EmitMethodBuilder)method;
emitMethodBuilder.Compile();
var il = methodBuilder.GetILGenerator();
GenerateIl(il, emitMethodBuilder.Il);
return(methodBuilder);
}
public static EmitMethodInvocationExpression Call(this EmitMethod method, params EmitExpression[] arguments)
{
return(new EmitMethodInvocationExpression(method, arguments));
}
public static EmitMethodInvocationExpression Invoke(this EmitExpression target, EmitMethod method, params EmitExpression[] arguments)
{
return(new EmitMethodInvocationExpression(target, method, arguments));
}
public static EmitMethodInvocationExpression Invoke(this EmitExpression target, EmitMethod method, params EmitExpression[] arguments)
{
return new EmitMethodInvocationExpression(target, method, arguments);
}
public EmitInstruction Emit(IEmitOpCodeMethod opCode, EmitMethod method)
{
var instruction = new EmitInstruction(opCode, method);
AddInstruction(instruction);
return instruction;
}
