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