public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args,
Reference targetField,
MethodEmitter invokeMethodOnTarget)
{
var @delegate = GetDelegate(invocation, invokeMethodOnTarget);
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), args);
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(invocation, parameters, invokeMethodOnTarget, targetField);
}
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 MethodEmitter CreateRemoveMethod(MethodAttributes atts)
{
if (removeMethod != null)
{
throw new InvalidOperationException("A remove method exists");
}
removeMethod = typeEmitter.CreateMethod("remove_" + name, atts);
return removeMethod;
}
public MethodEmitter CreateAddMethod(MethodAttributes atts)
{
if (addMethod != null)
{
throw new InvalidOperationException("An add method exists");
}
addMethod = typeEmitter.CreateMethod("add_" + name, atts);
return addMethod;
}
private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget)
{
var closedDelegateType = delegateType.MakeGenericType(invocation.GenericTypeParams);
var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType);
var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(invocation.GenericTypeParams);
var localTarget = new ReferenceExpression(targetReference);
invokeMethodOnTarget.CodeBuilder.AddStatement(
SetDelegate(localReference, localTarget, closedDelegateType, closedMethodOnTarget));
return localReference;
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
ProxyGenerationOptions options, INamingScope namingScope)
{
var targetReference = getTargetReference(@class, MethodToOverride);
emitter.CodeBuilder.AddStatement(
new ExpressionStatement(
new IfNullExpression(targetReference, IfNull(emitter.ReturnType), IfNotNull(targetReference))));
return emitter;
}
public MethodEmitter CreateAddMethod(string addMethodName, MethodAttributes attributes, MethodInfo methodToOverride)
{
if (addMethod != null)
{
throw new InvalidOperationException("An add method exists");
}
addMethod = new MethodEmitter(typeEmitter, addMethodName, attributes, methodToOverride);
return addMethod;
}
public MethodEmitter CreateGetMethod(string name, MethodAttributes attrs, MethodInfo methodToOverride, params Type[] parameters)
{
if (getMethod != null)
{
throw new InvalidOperationException("A get method exists");
}
getMethod = new MethodEmitter(parentTypeEmitter, name, attrs, methodToOverride);
return getMethod;
}
public MethodEmitter CreateRemoveMethod(string removeMethodName, MethodAttributes attributes,
MethodInfo methodToOverride)
{
if (removeMethod != null)
{
throw new InvalidOperationException("A remove method exists");
}
removeMethod = new MethodEmitter(typeEmitter, removeMethodName, attributes, methodToOverride);
return removeMethod;
}
public MethodEmitter CreateMethod(
string name,
MethodAttributes attributes,
MethodInfo methodToUseAsATemplate
)
{
var method = new MethodEmitter(this, name, attributes, methodToUseAsATemplate);
methods.Add(method);
return(method);
}
public MethodEmitter CreateSetMethod(string name, MethodAttributes attrs, MethodInfo methodToOverride,
params Type[] parameters)
{
if (setMethod != null)
{
throw new InvalidOperationException("A set method exists");
}
setMethod = new MethodEmitter(parentTypeEmitter, name, attrs, methodToOverride);
return(setMethod);
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
{
var targetReference = getTargetReference(@class, MethodToOverride);
var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
emitter.CodeBuilder.AddStatement(new ReturnStatement(
new MethodInvocationExpression(
targetReference,
MethodToOverride,
arguments) { VirtualCall = true }));
return emitter;
}
private void InitOutParameters(MethodEmitter emitter, ParameterInfo[] parameters)
{
for (var index = 0; index < parameters.Length; index++)
{
var parameter = parameters[index];
if (parameter.IsOut)
{
emitter.CodeBuilder.AddStatement(
new AssignArgumentStatement(new ArgumentReference(parameter.ParameterType, index + 1),
new DefaultValueExpression(parameter.ParameterType)));
}
}
}
public MethodEmitter CreateAddMethod(
string addMethodName,
MethodAttributes attributes,
MethodInfo methodToOverride
)
{
if (addMethod != null)
{
throw new InvalidOperationException("An add method exists");
}
addMethod = new MethodEmitter(typeEmitter, addMethodName, attributes, methodToOverride);
return(addMethod);
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
{
InitOutParameters(emitter, MethodToOverride.GetParameters());
if (emitter.ReturnType == typeof(void))
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement(new DefaultValueExpression(emitter.ReturnType)));
}
return emitter;
}
public static void CopyOutAndRefParameters(TypeReference[] dereferencedArguments, LocalReference invocation, MethodInfo method, MethodEmitter emitter)
{
var parameters = method.GetParameters();
if (!ArgumentsUtil.IsAnyByRef(parameters))
{
return; //saving the need to create locals if there is no need
}
var arguments = StoreInvocationArgumentsInLocal(emitter, invocation);
for (int i = 0; i < parameters.Length; i++)
{
if (!parameters[i].ParameterType.IsByRef) continue;
emitter.CodeBuilder.AddStatement(AssignArgument(dereferencedArguments, i, arguments));
}
}
public MethodEmitter CreateRemoveMethod(
string removeMethodName,
MethodAttributes attributes,
MethodInfo methodToOverride
)
{
if (removeMethod != null)
{
throw new InvalidOperationException("A remove method exists");
}
removeMethod = new MethodEmitter(
typeEmitter,
removeMethodName,
attributes,
methodToOverride
);
return(removeMethod);
}
public MethodEmitter CreateMethod(
string name,
MethodAttributes attrs,
Type returnType,
params Type[] argumentTypes
)
{
var member = new MethodEmitter(
this,
name,
attrs,
returnType,
argumentTypes ?? Type.EmptyTypes
);
methods.Add(member);
return(member);
}
public MethodEmitter CreateSetMethod(string name, MethodAttributes attrs, params Type[] parameters)
{
if (setMethod != null)
{
throw new InvalidOperationException("A set method exists");
}
if (parameters.Length == 0)
{
setMethod = new MethodEmitter(parentTypeEmitter, name, attrs);
}
else
{
setMethod = new MethodEmitter(parentTypeEmitter, name,
attrs, typeof(void),
parameters);
}
return(setMethod);
}
public MethodEmitter CreateGetMethod(string name, MethodAttributes attrs, params Type[] parameters)
{
if (getMethod != null)
{
throw new InvalidOperationException("A get method exists");
}
if (parameters.Length == 0)
{
getMethod = new MethodEmitter(parentTypeEmitter, name, attrs);
}
else
{
getMethod = new MethodEmitter(parentTypeEmitter, name,
attrs,
ReturnType,
parameters);
}
return getMethod;
}
private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Reference invocationLocal)
{
#if SILVERLIGHT
Type[] genericParameters =
Castle.Core.Extensions.SilverlightExtensions.FindAll(method.GetGenericArguments(), t => t.IsGenericParameter);
#else
Type[] genericParameters = Array.FindAll(method.GetGenericArguments(), t => t.IsGenericParameter);
#endif
LocalReference genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));
for (int i = 0; i < genericParameters.Length; ++i)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
}
methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(invocationLocal,
InvocationMethods.SetGenericMethodArguments,
new ReferenceExpression(
genericParamsArrayLocal))));
}
protected MethodEmitter ImplementProxiedMethod(
Type targetType,
MethodEmitter methodEmitter,
MethodInfo method,
ClassEmitter emitter,
NestedClassEmitter invocationImpl,
FieldReference interceptorsField,
Reference targetRef,
ConstructorVersion version,
MethodInfo methodOnTarget)
{
CheckNotGenericTypeDefinition(targetType, "targetType");
methodEmitter.CopyParametersAndReturnTypeFrom(method, emitter);
TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(methodEmitter.Arguments);
Type iinvocation = invocationImpl.TypeBuilder;
Trace.Assert(method.IsGenericMethod == iinvocation.IsGenericTypeDefinition);
bool isGenericInvocationClass = false;
Type[] genericMethodArgs = new Type[0];
if (method.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericMethodArgs = methodEmitter.MethodBuilder.GetGenericArguments();
iinvocation = iinvocation.MakeGenericType(genericMethodArgs);
isGenericInvocationClass = true;
}
Expression typeTokenFieldExp = typeTokenField.ToExpression();
Expression methodInfoTokenExp;
string tokenFieldName;
if (method2TokenField.ContainsKey(method)) // Token is in the cache
{
FieldReference methodTokenField = method2TokenField[method];
tokenFieldName = methodTokenField.Reference.Name;
methodInfoTokenExp = methodTokenField.ToExpression();
}
else
{
// Not in the cache: generic method
MethodInfo genericMethod = method.MakeGenericMethod(genericMethodArgs);
// Need random suffix added to the name, so that we don't end up with duplicate field names for
// methods with the same name, but different generic parameters
tokenFieldName = string.Format("{0}_{1}_{2}", genericMethod.Name, genericMethodArgs.Length,
Guid.NewGuid().ToString("N"));
methodInfoTokenExp = new MethodTokenExpression(genericMethod);
}
LocalReference invocationImplLocal = methodEmitter.CodeBuilder.DeclareLocal(iinvocation);
// TODO: Initialize iinvocation instance with ordinary arguments and in and out arguments
Expression interceptors = interceptorsField.ToExpression();
// Create the field to store the selected interceptors for this method if an InterceptorSelector is specified
FieldReference methodInterceptors = null;
if (proxyGenerationOptions.Selector != null)
{
// If no interceptors are returned, should we invoke the base.Method directly? Looks like we should not.
methodInterceptors = emitter.CreateField(string.Format("{0}_interceptors", tokenFieldName), typeof(IInterceptor[]));
}
ConstructorInfo constructor = invocationImpl.Constructors[0].ConstructorBuilder;
if (isGenericInvocationClass)
{
constructor = TypeBuilder.GetConstructor(iinvocation, constructor);
}
NewInstanceExpression newInvocImpl;
if (version == ConstructorVersion.WithTargetMethod)
{
Expression methodOnTargetTokenExp;
if (method2TokenField.ContainsKey(methodOnTarget)) // Token is in the cache
{
methodOnTargetTokenExp = method2TokenField[methodOnTarget].ToExpression();
}
else
{
// Not in the cache: generic method
methodOnTargetTokenExp = new MethodTokenExpression(methodOnTarget.MakeGenericMethod(genericMethodArgs));
}
if (methodInterceptors == null)
{
newInvocImpl = //actual contructor call
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodOnTargetTokenExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression());
}
else
{
MethodInvocationExpression methodInvocationExpression =
new MethodInvocationExpression(proxyGenerationOptionsField, proxyGenerationOptions_Selector);
methodInvocationExpression.VirtualCall = true;
newInvocImpl = //actual contructor call
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodOnTargetTokenExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression(),
methodInvocationExpression,
new AddressOfReferenceExpression(methodInterceptors));
}
}
else
{
if (methodInterceptors == null)
{
newInvocImpl =
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression());
}
else
{
MethodInvocationExpression methodInvocationExpression =
new MethodInvocationExpression(proxyGenerationOptionsField, proxyGenerationOptions_Selector);
methodInvocationExpression.VirtualCall = true;
newInvocImpl =
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression(),
methodInvocationExpression,
new AddressOfReferenceExpression(methodInterceptors));
}
}
methodEmitter.CodeBuilder.AddStatement(new AssignStatement(invocationImplLocal, newInvocImpl));
if (method.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(methodEmitter, method.MakeGenericMethod(genericMethodArgs), invocationImplLocal);
}
methodEmitter.CodeBuilder.AddStatement(
new ExpressionStatement(new MethodInvocationExpression(invocationImplLocal, Constants.AbstractInvocationProceed)));
CopyOutAndRefParameters(dereferencedArguments, invocationImplLocal, method, methodEmitter);
if (method.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
MethodInvocationExpression getRetVal =
new MethodInvocationExpression(invocationImplLocal, typeof(AbstractInvocation).GetMethod("get_ReturnValue"));
methodEmitter.CodeBuilder.AddStatement(
new ReturnStatement(new ConvertExpression(methodEmitter.ReturnType, getRetVal)));
}
else
{
methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return methodEmitter;
}
private static LocalReference StoreInvocationArgumentsInLocal(MethodEmitter emitter, LocalReference invocation)
{
var invocationArgs = emitter.CodeBuilder.DeclareLocal(typeof(object[]));
emitter.CodeBuilder.AddStatement(GetArguments(invocationArgs, invocation));
return invocationArgs;
}
protected override void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData,
FieldReference field)
{
serializedFields.Add(field);
base.AddAddValueInvocation(serializationInfo, getObjectData, field);
}
protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData,
FieldReference field)
{
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
serializationInfo,
SerializationInfoMethods.AddValue_Object,
new ConstReference(field.Reference.Name).ToExpression(),
field.ToExpression())));
return;
}
protected void ReplicateNonInheritableAttributes(MethodInfo method, MethodEmitter emitter)
{
object[] attrs = method.GetCustomAttributes(false);
foreach(Attribute attribute in attrs)
{
if (ShouldSkipAttributeReplication(attribute)) continue;
emitter.DefineCustomAttribute(attribute);
}
}
public MethodEmitter CreateSetMethod(MethodAttributes attrs, params Type[] parameters)
{
if (setMethod != null)
{
throw new InvalidOperationException("A setMethod exists");
}
if (parameters.Length == 0)
{
setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name, attrs);
}
else
{
setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name,
attrs, typeof (void),
parameters);
}
return setMethod;
}
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();
}
private static void CopyOutAndRefParameters(
TypeReference[] dereferencedArguments, LocalReference invocationImplLocal, MethodInfo method,
MethodEmitter methodEmitter)
{
ParameterInfo[] parameters = method.GetParameters();
bool hasByRefParam = false;
for(int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
hasByRefParam = true;
}
if (!hasByRefParam)
return; //saving the need to create locals if there is no need
LocalReference invocationArgs = methodEmitter.CodeBuilder.DeclareLocal(typeof(object[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(invocationArgs,
new MethodInvocationExpression(invocationImplLocal, invocation_getArgumentsMethod)
)
);
for(int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(dereferencedArguments[i],
new ConvertExpression(dereferencedArguments[i].Type,
new LoadRefArrayElementExpression(i, invocationArgs)
)
));
}
}
}
private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method,
LocalReference invocationImplLocal)
{
Type[] genericParameters =
Array.FindAll(method.GetGenericArguments(), delegate(Type t) { return t.IsGenericParameter; });
LocalReference genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));
for(int i = 0; i < genericParameters.Length; ++i)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
}
MethodInfo setGenericsArgs =
typeof(AbstractInvocation).GetMethod("SetGenericMethodArguments", new Type[] {typeof(Type[])});
methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(invocationImplLocal, setGenericsArgs,
new ReferenceExpression(
genericParamsArrayLocal))));
}
protected MethodEmitter ImplementProxiedMethod(
Type targetType,
MethodEmitter methodEmitter,
MethodInfo method,
ClassEmitter emitter,
NestedClassEmitter invocationImpl,
FieldReference interceptorsField,
Reference targetRef,
ConstructorVersion version,
MethodInfo methodOnTarget)
{
CheckNotGenericTypeDefinition(targetType, "targetType");
methodEmitter.CopyParametersAndReturnTypeFrom(method, emitter);
TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(methodEmitter.Arguments);
Type iinvocation = invocationImpl.TypeBuilder;
Trace.Assert(method.IsGenericMethod == iinvocation.IsGenericTypeDefinition);
bool isGenericInvocationClass = false;
Type[] genericMethodArgs = new Type[0];
if (method.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericMethodArgs = methodEmitter.MethodBuilder.GetGenericArguments();
iinvocation = iinvocation.MakeGenericType(genericMethodArgs);
isGenericInvocationClass = true;
}
LocalReference invocationImplLocal = methodEmitter.CodeBuilder.DeclareLocal(iinvocation);
// TODO: Initialize iinvocation instance
// with ordinary arguments and in and out arguments
Expression interceptors;
// if (useSelector)
{
// TODO: Generate code that checks the return of selector
// if no interceptors is returned, should we invoke the base.Method directly?
}
// else
{
interceptors = interceptorsField.ToExpression();
}
Expression typeTokenFieldExp = typeTokenField.ToExpression();
Expression methodInfoTokenExp;
if (method2TokenField.ContainsKey(method)) // Token is in the cache
{
methodInfoTokenExp = ((FieldReference) method2TokenField[method]).ToExpression();
}
else
{
// Not in the cache: generic method
methodInfoTokenExp = new MethodTokenExpression(method.MakeGenericMethod(genericMethodArgs));
}
ConstructorInfo constructor = invocationImpl.Constructors[0].ConstructorBuilder;
if (isGenericInvocationClass)
{
constructor = TypeBuilder.GetConstructor(iinvocation, invocationImpl.Constructors[0].ConstructorBuilder);
}
NewInstanceExpression newInvocImpl;
if (version == ConstructorVersion.WithTargetMethod)
{
Expression methodOnTargetTokenExp;
if (method2TokenField.ContainsKey(methodOnTarget)) // Token is in the cache
{
methodOnTargetTokenExp = ((FieldReference) method2TokenField[methodOnTarget]).ToExpression();
}
else
{
// Not in the cache: generic method
methodOnTargetTokenExp = new MethodTokenExpression(methodOnTarget.MakeGenericMethod(genericMethodArgs));
}
newInvocImpl =
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodOnTargetTokenExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression());
}
else
{
newInvocImpl =
new NewInstanceExpression(constructor,
targetRef.ToExpression(),
interceptors,
typeTokenFieldExp,
methodInfoTokenExp,
new ReferencesToObjectArrayExpression(dereferencedArguments),
SelfReference.Self.ToExpression());
}
methodEmitter.CodeBuilder.AddStatement(new AssignStatement(invocationImplLocal, newInvocImpl));
if (method.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(methodEmitter, method.MakeGenericMethod(genericMethodArgs), invocationImplLocal);
}
methodEmitter.CodeBuilder.AddStatement(
new ExpressionStatement(new MethodInvocationExpression(invocationImplLocal, Constants.AbstractInvocationProceed)));
CopyOutAndRefParameters(dereferencedArguments, invocationImplLocal, method, methodEmitter);
if (method.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
MethodInvocationExpression getRetVal =
new MethodInvocationExpression(invocationImplLocal, typeof(AbstractInvocation).GetMethod("get_ReturnValue"));
methodEmitter.CodeBuilder.AddStatement(
new ReturnStatement(new ConvertExpression(methodEmitter.ReturnType, getRetVal)));
}
else
{
methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return methodEmitter;
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options,INamingScope namingScope)
{
var invocationType = invocation;
Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition);
Type[] genericMethodArgs = Type.EmptyTypes;
ConstructorInfo constructor = invocation.GetConstructors()[0];
Expression proxiedMethodTokenExpression;
if (MethodToOverride.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericMethodArgs = emitter.MethodBuilder.GetGenericArguments();
invocationType = invocationType.MakeGenericType(genericMethodArgs);
constructor = TypeBuilder.GetConstructor(invocationType, constructor);
// Not in the cache: generic method
proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericMethodArgs));
}
else
{
var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo));
@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride)));
proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
}
var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
var ctorArguments = GetCtorArguments(@class, namingScope, proxiedMethodTokenExpression, dereferencedArguments);
var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
new NewInstanceExpression(constructor, ctorArguments)));
if (MethodToOverride.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericMethodArgs), invocationLocal);
}
emitter.CodeBuilder.AddStatement(
new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed)));
GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);
if (MethodToOverride.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return emitter;
}
public void Add(MethodEmitter method)
{
InnerList.Add(method);
}
private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Reference invocationLocal)
{
var genericParameters = new List<Type>(method.GetGenericArguments()).FindAll(t => t.IsGenericParameter);
var genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Count, typeof(Type))));
for (var i = 0; i < genericParameters.Count; ++i)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
}
methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(invocationLocal,
InvocationMethods.SetGenericMethodArguments,
new ReferenceExpression(
genericParamsArrayLocal))));
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
ProxyGenerationOptions options, INamingScope namingScope)
{
var invocationType = invocation;
Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition());
var genericArguments = TypeExtender.EmptyTypes;
var constructor = invocation.GetConstructors()[0];
Expression proxiedMethodTokenExpression;
if (MethodToOverride.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericArguments = emitter.MethodBuilder.GetGenericArguments();
invocationType = invocationType.MakeGenericType(genericArguments);
constructor = TypeBuilder.GetConstructor(invocationType, constructor);
// Not in the cache: generic method
proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments));
}
else
{
var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name),
typeof(MethodInfo));
@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken,
new MethodTokenExpression(MethodToOverride)));
proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
}
var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
var hasByRefArguments = HasByRefArguments(emitter.Arguments);
var arguments = GetCtorArguments(@class, namingScope, proxiedMethodTokenExpression,
dereferencedArguments);
var ctorArguments = ModifyArguments(@class, arguments);
var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
new NewInstanceExpression(constructor, ctorArguments)));
if (MethodToOverride.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal);
}
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new TryStatement());
}
var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed));
emitter.CodeBuilder.AddStatement(proceed);
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new FinallyStatement());
}
GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement());
}
if (MethodToOverride.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
// @mbrit - 2012-05-31 - see the note associated with the GetReturnValueForWinRt declaration
// for more information on this...
var useWinRtGenericHandler = false;
#if NETFX_CORE
if (emitter.ReturnType == typeof(int) || emitter.ReturnType == typeof(bool))
useWinRtGenericHandler = true;
#endif
if(!(useWinRtGenericHandler))
{
var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
}
else
{
#if NETFX_CORE
var grvArgs = new Type[] { emitter.ReturnType };
var grvCall = InvocationMethods.GetReturnValueForWinRt.MakeGenericMethod(grvArgs);
var getRetVal = new MethodInvocationExpression(invocationLocal, grvCall);
emitter.CodeBuilder.AddStatement(new ReturnStatement(getRetVal));
#endif
}
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return emitter;
}
