public Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
{
var allArguments = new Expression[arguments.Length + 1];
allArguments[0] = new ReferenceExpression(BuildDelegateToken(proxy));
Array.Copy(arguments, 0, allArguments, 1, arguments.Length);
return allArguments;
}
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args,
Reference targetField,
MethodEmitter invokeMethodOnTarget)
{
var @delegate = GetDelegate(invocation, invokeMethodOnTarget);
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), args);
}
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args,
Reference targetField,
MethodEmitter invokeMethodOnTarget)
{
var allArgs = GetAllArgs(args, targetField);
var @delegate = (Reference)invocation.GetField("delegate");
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), allArgs);
}
public static Expression[] ConvertArgumentReferenceToExpression(ArgumentReference[] args)
{
var expressions = new Expression[args.Length];
for (var i = 0; i < args.Length; ++i)
{
expressions[i] = args[i].ToExpression();
}
return expressions;
}
public BindDelegateExpression(Type @delegate, Expression owner, MethodInfo methodToBindTo,
GenericTypeParameterBuilder[] genericTypeParams)
{
delegateCtor = @delegate.GetConstructors()[0];
this.methodToBindTo = methodToBindTo;
if (@delegate.IsGenericTypeDefinition)
{
var closedDelegate = @delegate.MakeGenericType(genericTypeParams);
delegateCtor = TypeBuilder.GetConstructor(closedDelegate, delegateCtor);
this.methodToBindTo = methodToBindTo.MakeGenericMethod(genericTypeParams);
}
this.owner = owner;
}
public NullCoalescingOperatorExpression(Expression expression, Expression @default)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
if (@default == null)
{
throw new ArgumentNullException("default");
}
this.expression = expression;
this.@default = @default;
}
public void AddExpression(Expression expression)
{
AddStatement(new ExpressionStatement(expression));
}
private Expression[] ModifyArguments(ClassEmitter @class, Expression[] arguments)
{
if (contributor == null)
{
return arguments;
}
return contributor.GetConstructorInvocationArguments(arguments, @class);
}
private Expression[] GetCtorArguments(ClassEmitter @class, Expression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments, Expression methodInterceptors)
{
return new[]
{
getTargetExpression(@class, MethodToOverride),
SelfReference.Self.ToExpression(),
methodInterceptors ?? interceptors.ToExpression(),
proxiedMethodTokenExpression,
new ReferencesToObjectArrayExpression(dereferencedArguments)
};
}
private Expression SetMethodInterceptors(ClassEmitter @class, INamingScope namingScope, MethodEmitter emitter, Expression proxiedMethodTokenExpression)
{
var selector = @class.GetField("__selector");
if(selector == null)
{
return null;
}
var methodInterceptorsField = BuildMethodInterceptorsField(@class, MethodToOverride, namingScope);
var emptyInterceptors = new NewArrayExpression(0, typeof(IInterceptor));
var selectInterceptors = new MethodInvocationExpression(selector, InterceptorSelectorMethods.SelectInterceptors,
new MethodInvocationExpression(null,
TypeUtilMethods.GetTypeOrNull,
getTargetExpression(@class, MethodToOverride)),
proxiedMethodTokenExpression, interceptors.ToExpression())
{ VirtualCall = true };
emitter.CodeBuilder.AddExpression(
new IfNullExpression(methodInterceptorsField,
new AssignStatement(methodInterceptorsField,
new NullCoalescingOperatorExpression(selectInterceptors, emptyInterceptors))));
return methodInterceptorsField.ToExpression();
}
public ConvertExpression(Type targetType, Expression right)
: this(targetType, typeof(object), right)
{
}
public AssignArgumentStatement(ArgumentReference argument, Expression expression)
{
this.argument = argument;
this.expression = expression;
}
public Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
{
return arguments;
}
public ReturnStatement(Expression expression)
{
this.expression = expression;
}
public AssignStatement(Reference target, Expression expression)
{
this.target = target;
this.expression = expression;
}
public AbstractCodeBuilder AddExpression(Expression expression)
{
return AddStatement(new ExpressionStatement(expression));
}
public ConvertExpression(Type targetType, Type fromType, Expression right)
{
target = targetType;
this.fromType = fromType;
this.right = right;
}
public AssignArrayStatement(Reference targetArray, int targetPosition, Expression value)
{
this.targetArray = targetArray;
this.targetPosition = targetPosition;
this.value = value;
}
private Expression[] GetAllArgs(Expression[] args, Reference targetField)
{
var allArgs = new Expression[args.Length + 1];
args.CopyTo(allArgs, 1);
allArgs[0] = new ConvertExpression(targetType, targetField.ToExpression());
return allArgs;
}
private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
{
var targetMethod = methodOnTarget ?? methodInfo;
var callBackMethod = emitter.CreateMethod(namingScope.GetUniqueName(methodInfo.Name + "_callback"), targetMethod);
if (targetMethod.IsGenericMethod)
{
targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
}
var exps = new Expression[callBackMethod.Arguments.Length];
for (var i = 0; i < callBackMethod.Arguments.Length; i++)
{
exps[i] = callBackMethod.Arguments[i].ToExpression();
}
// invocation on base class
callBackMethod.CodeBuilder.AddStatement(
new ReturnStatement(
new MethodInvocationExpression(SelfReference.Self,
targetMethod,
exps)));
return callBackMethod.MethodBuilder;
}
