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; }