protected FieldReference CreateOptionsField(ClassEmitter emitter)
{
return(emitter.CreateStaticField(
"proxyGenerationOptions",
typeof(ProxyGenerationOptions)
));
}
public void CreateStaticFieldWithAttributes()
{
ClassEmitter emitter = new ClassEmitter(generator.ProxyBuilder.ModuleScope, "Foo", typeof(object), Type.EmptyTypes);
emitter.CreateStaticField("myField", typeof(string), FieldAttributes.FamANDAssem | FieldAttributes.InitOnly);
Type t = emitter.BuildType();
FieldInfo field = t.GetField("myField", BindingFlags.NonPublic | BindingFlags.Static);
Assert.IsNotNull(field);
Assert.AreEqual(FieldAttributes.Static | FieldAttributes.FamANDAssem | FieldAttributes.InitOnly, field.Attributes);
}
private FieldReference BuildDelegateToken(ClassEmitter proxy)
{
var callback = proxy.CreateStaticField(namingScope.GetUniqueName("callback_" + method.Method.Name), delegateType);
var createDelegate = new MethodInvocationExpression(
null,
DelegateMethods.CreateDelegate,
new TypeTokenExpression(delegateType),
NullExpression.Instance,
new MethodTokenExpression(method.MethodOnTarget));
var bindDelegate = new AssignStatement(callback, new ConvertExpression(delegateType, createDelegate));
proxy.ClassConstructor.CodeBuilder.AddStatement(bindDelegate);
return(callback);
}
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(IMethodInfo));
@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))
{
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);
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, INamingScope namingScope)
{
var invocationType = invocation;
Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition);
var genericArguments = Type.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 methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression);
var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
var hasByRefArguments = HasByRefArguments(emitter.Arguments);
var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors);
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))
{
var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
// Emit code to ensure a value type return type is not null, otherwise the cast will cause a null-deref
if (emitter.ReturnType.IsValueType && !emitter.ReturnType.IsNullableType())
{
LocalReference returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object));
emitter.CodeBuilder.AddStatement(new AssignStatement(returnValue, getRetVal));
emitter.CodeBuilder.AddExpression(new IfNullExpression(returnValue, new ThrowStatement(typeof(InvalidOperationException),
"Interceptors failed to set a return value, or swallowed the exception thrown by the target")));
}
// Emit code to return with cast from ReturnValue
emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return(emitter);
}
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);
}