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 NestedClassEmitter(AbstractTypeEmitter maintype, String name, Type baseType, Type[] interfaces)
: this(
maintype,
CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
baseType, interfaces))
{
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
if (TypeBuilderMethods.DefineProperty == null || true) // TODO
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter @class, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, MethodInfo callbackMethod, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(@class, parameters, invokeMethodOnTarget, callbackMethod, targetField);
}
public static Type GetClosedParameterType(this AbstractTypeEmitter type, Type parameter)
{
if (parameter.IsGenericTypeDefinition)
{
return(parameter.GetGenericTypeDefinition().MakeGenericType(type.GetGenericArgumentsFor(parameter)));
}
if (parameter.IsGenericType)
{
var arguments = parameter.GetGenericArguments();
if (CloseGenericParametersIfAny(type, arguments))
{
return(parameter.GetGenericTypeDefinition().MakeGenericType(arguments));
}
}
if (parameter.IsGenericParameter)
{
return(type.GetGenericArgument(parameter.Name));
}
if (parameter.IsArray)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return(elementType.MakeArrayType());
}
if (parameter.IsByRef)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return(elementType.MakeByRefType());
}
return(parameter);
}
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args,
Reference targetField,
MethodEmitter invokeMethodOnTarget)
{
var @delegate = GetDelegate(invocation, invokeMethodOnTarget);
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), args);
}
public ConstructorEmitter CreateConstructor(
ArgumentReference[] baseCtorArguments,
AbstractTypeEmitter invocation
)
{
return(invocation.CreateConstructor(baseCtorArguments));
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter @class, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, MethodInfo callbackMethod, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(@class, parameters, invokeMethodOnTarget, callbackMethod, targetField);
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, MethodInfo method,
MethodEmitter invokeMethodOnTarget, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(invocation, method, invokeMethodOnTarget, targetField);
}
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes,
Type baseType, Type[] interfaces)
{
return maintype.TypeBuilder.DefineNestedType(
name,
attributes,
baseType, interfaces);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, Type returnType,
params Type[] argumentTypes)
: this(owner, name, attributes)
{
SetParameters(argumentTypes);
SetReturnType(returnType);
}
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, MethodInfo method,
MethodEmitter invokeMethodOnTarget, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(invocation, method, invokeMethodOnTarget, targetField);
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
var arguments = GetArguments(baseCtorArguments);
var constructor = invocation.CreateConstructor(arguments);
var delegateField = invocation.CreateField("delegate", delegateType);
constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, new ReferenceExpression(arguments[0])));
return constructor;
}
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);
}
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;
}
private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget)
{
var closedDelegateType = delegateType.MakeGenericType(invocation.GenericTypeParams.AsTypes().ToArray());
var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType);
var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(invocation.GenericTypeParams.AsTypes().ToArray());
var localTarget = new ReferenceExpression(targetReference);
invokeMethodOnTarget.CodeBuilder.AddStatement(
SetDelegate(localReference, localTarget, closedDelegateType, closedMethodOnTarget));
return(localReference);
}
public ConstructorEmitter CreateConstructor(
ArgumentReference[] baseCtorArguments,
AbstractTypeEmitter invocation
)
{
var arguments = GetArguments(baseCtorArguments);
var constructor = invocation.CreateConstructor(arguments);
var delegateField = invocation.CreateField("delegate", delegateType);
constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, arguments[0]));
return(constructor);
}
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
this.typeEmitter = typeEmitter;
this.type = type;
eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type);
}
private static bool CloseGenericParametersIfAny(AbstractTypeEmitter emitter, Type[] arguments)
{
var hasAnyGenericParameters = false;
for (var i = 0; i < arguments.Length; i++)
{
var newType = GetClosedParameterType(emitter, arguments[i]);
if (newType != null && !ReferenceEquals(newType, arguments[i]))
{
arguments[i] = newType;
hasAnyGenericParameters = true;
}
}
return(hasAnyGenericParameters);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, MethodInfo methodToUseAsATemplate)
: this(owner, name, attributes)
{
var name2GenericType = GenericUtil.GetGenericArgumentsMap(owner);
var returnType = GenericUtil.ExtractCorrectType(methodToUseAsATemplate.ReturnType, name2GenericType);
var baseMethodParameters = methodToUseAsATemplate.GetParameters();
var parameters = GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType);
genericTypeParams = GenericUtil.CopyGenericArguments(methodToUseAsATemplate, builder, name2GenericType);
SetParameters(parameters);
SetReturnType(returnType);
SetSignature(returnType, methodToUseAsATemplate.ReturnParameter, parameters, baseMethodParameters);
DefineParameters(baseMethodParameters);
}
internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)
{
this.maintype = maintype;
var args = ArgumentsUtil.InitializeAndConvert(arguments);
builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
// if we don't copy the parameter attributes, the default binder will fail
// when trying to resolve constructors from the passed argument values.
for (int i = 0; i < args.Length; ++i)
{
var arg = arguments[i];
var paramBuilder = builder.DefineParameter(i + 1, arg.ParameterAttributes, "");
if (arg.DefaultValue != DBNull.Value)
paramBuilder.SetConstant(arg.DefaultValue);
}
}
internal TypeConstructorEmitter(AbstractTypeEmitter maintype)
: base(maintype, maintype.TypeBuilder.DefineTypeInitializer())
{
}
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes)
: this(owner.TypeBuilder.DefineMethod(name, attributes))
{
}
private static bool CloseGenericParametersIfAny(AbstractTypeEmitter emitter, Type[] arguments)
{
var hasAnyGenericParameters = false;
for (var i = 0; i < arguments.Length; i++)
{
var newType = GetClosedParameterType(emitter, arguments[i]);
if (newType != null && !ReferenceEquals(newType, arguments[i]))
{
arguments[i] = newType;
hasAnyGenericParameters = true;
}
}
return hasAnyGenericParameters;
}
public static Dictionary<string, GenericTypeParameterBuilder> GetGenericArgumentsMap(AbstractTypeEmitter parentEmitter)
{
if (parentEmitter.GenericTypeParams == null || parentEmitter.GenericTypeParams.Length == 0)
{
return new Dictionary<string, GenericTypeParameterBuilder>(0);
}
var name2GenericType = new Dictionary<string, GenericTypeParameterBuilder>(parentEmitter.GenericTypeParams.Length);
foreach (var genType in parentEmitter.GenericTypeParams)
{
name2GenericType.Add(genType.Name, genType);
}
return name2GenericType;
}
public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)
: base(typeBuilder)
{
maintype.Nested.Add(this);
}
public CustomClassEmitter(AbstractTypeEmitter innerEmitter)
{
ArgumentUtility.CheckNotNull("innerEmitter", innerEmitter);
_innerEmitter = innerEmitter;
}
protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder)
{
this.maintype = maintype;
this.builder = builder;
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
return invocation.CreateConstructor(baseCtorArguments);
}
