private MethodInfo CreateNonVirtualCallTrampoline(CodeGenerationContext context, MethodInfo method, string trampolineName)
{
var methodDeclaration = MethodDeclaration.CreateEquivalent(method);
var trampoline = context.MutableType.AddMethod(
trampolineName,
MethodAttributes.Private,
methodDeclaration,
ctx => Expression.Call(ctx.This, NonVirtualCallMethodInfoAdapter.Adapt(method), ctx.Parameters.Cast <Expression>()));
_memberEmitter.AddMethod(context, trampoline);
return(trampoline);
}
private Action CreateExplicitOverrideBuildAction(CodeGenerationContext context, MutableMethodInfo overridingMethod)
{
return(() =>
{
var emittableOverridingMethod = context.EmittableOperandProvider.GetEmittableMethod(overridingMethod);
foreach (var overriddenMethod in overridingMethod.AddedExplicitBaseDefinitions)
{
var emittableOverriddenMethod = context.EmittableOperandProvider.GetEmittableMethod(overriddenMethod);
context.TypeBuilder.DefineMethodOverride(emittableOverridingMethod, emittableOverriddenMethod);
}
});
}
private Action CreateBodyBuildAction(
CodeGenerationContext context,
IMethodBaseBuilder methodBuilder,
IEnumerable <ParameterExpression> parameterExpressions,
Expression unpreparedBody)
{
// Bodies need to be generated after all other members have been declared (to allow bodies to reference new members).
return(() =>
{
var body = _expressionPreparer.PrepareBody(context, unpreparedBody);
var bodyLambda = Expression.Lambda(body, parameterExpressions);
methodBuilder.SetBody(bodyLambda, _ilGeneratorFactory, context.DebugInfoGenerator);
});
}
private void DefineGenericParameters(CodeGenerationContext context, IMethodBuilder methodBuilder, MutableMethodInfo method)
{
if (!method.IsGenericMethodDefinition)
{
return;
}
var genericParameterNames = method.MutableGenericParameters.Select(p => p.Name).ToArray();
var genericParametersBuilders = methodBuilder.DefineGenericParameters(genericParameterNames);
foreach (var pair in genericParametersBuilders.Zip(method.MutableGenericParameters, (b, g) => new { Builder = b, GenericParameter = g }))
{
pair.Builder.RegisterWith(context.EmittableOperandProvider, pair.GenericParameter);
DefineGenericParameter(pair.Builder, pair.GenericParameter);
}
}
public MethodInfo GetNonVirtualCallTrampoline(CodeGenerationContext context, MethodInfo method)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("method", method);
MethodInfo trampoline;
if (!context.TrampolineMethods.TryGetValue(method, out trampoline))
{
var name = string.Format("{0}.{1}_NonVirtualCallTrampoline", method.DeclaringType.FullName, method.Name);
trampoline = CreateNonVirtualCallTrampoline(context, method, name);
context.TrampolineMethods.Add(method, trampoline);
}
return(trampoline);
}
public void AddConstructor(CodeGenerationContext context, MutableConstructorInfo constructor)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("constructor", constructor);
var parameterTypes = GetParameterTypes(constructor);
var ctorBuilder = context.TypeBuilder.DefineConstructor(constructor.Attributes, constructor.CallingConvention, parameterTypes);
ctorBuilder.RegisterWith(context.EmittableOperandProvider, constructor);
DefineParameters(ctorBuilder, constructor);
DefineCustomAttributes(ctorBuilder, constructor);
var bodyBuildAction = CreateBodyBuildAction(context, ctorBuilder, constructor.ParameterExpressions, constructor.Body);
context.PostDeclarationsActionManager.AddAction(bodyBuildAction);
}
public void AddEvent(CodeGenerationContext context, MutableEventInfo event_)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("event_", event_);
var addMethod = event_.MutableAddMethod;
var removeMethod = event_.MutableRemoveMethod;
var raiseMethod = event_.MutableRaiseMethod;
var eventBuilder = context.TypeBuilder.DefineEvent(event_.Name, event_.Attributes, event_.EventHandlerType);
DefineCustomAttributes(eventBuilder, event_);
eventBuilder.SetAddOnMethod(context.MethodBuilders[addMethod]);
eventBuilder.SetRemoveOnMethod(context.MethodBuilders[removeMethod]);
if (raiseMethod != null)
{
eventBuilder.SetRaiseMethod(context.MethodBuilders[raiseMethod]);
}
}
private void WireAndAddConstructor(
IMemberEmitter member, CodeGenerationContext context, MutableConstructorInfo constructor, Tuple <FieldInfo, MethodInfo> initializationMembers)
{
_initializationBuilder.WireConstructorWithInitialization(constructor, initializationMembers, _proxySerializationEnabler);
member.AddConstructor(context, constructor);
}