public override void Emit(EmitContext ec)
{
if (method_group.InstanceExpression == null)
{
ec.EmitNull();
}
else
{
method_group.InstanceExpression.Emit(ec);
}
var delegate_method = method_group.BestCandidate;
// Any delegate must be sealed
if (!delegate_method.DeclaringType.IsDelegate && delegate_method.IsVirtual && !method_group.IsBase)
{
ec.Emit(OpCodes.Dup);
ec.Emit(OpCodes.Ldvirtftn, delegate_method);
}
else
{
ec.Emit(OpCodes.Ldftn, delegate_method);
}
ec.Emit(OpCodes.Newobj, constructor_method);
}
public override void Emit (EmitContext ec)
{
if (method_group.InstanceExpression == null)
ec.EmitNull ();
else
method_group.InstanceExpression.Emit (ec);
var delegate_method = method_group.BestCandidate;
// Any delegate must be sealed
if (!delegate_method.DeclaringType.IsDelegate && delegate_method.IsVirtual && !method_group.IsBase) {
ec.Emit (OpCodes.Dup);
ec.Emit (OpCodes.Ldvirtftn, delegate_method);
} else {
ec.Emit (OpCodes.Ldftn, delegate_method);
}
ec.Emit (OpCodes.Newobj, constructor_method);
}
public override void Emit (EmitContext ec)
{
if (Value == null) {
ec.EmitNull ();
return;
}
//
// Use string.Empty for both literals and constants even if
// it's not allowed at language level
//
if (Value.Length == 0 && ec.Module.Compiler.Settings.Optimize) {
var string_type = ec.BuiltinTypes.String;
if (ec.CurrentType != string_type) {
var m = ec.Module.PredefinedMembers.StringEmpty.Get ();
if (m != null) {
ec.Emit (OpCodes.Ldsfld, m);
return;
}
}
}
ec.Emit (OpCodes.Ldstr, Value);
}
public override void Emit (EmitContext ec)
{
ec.EmitNull ();
// Only to make verifier happy
if (type.IsGenericParameter)
ec.Emit (OpCodes.Unbox_Any, type);
}
public override void Emit (EmitContext ec)
{
//
// Use same anonymous method implementation for scenarios where same
// code is used from multiple blocks, e.g. field initializers
//
if (method == null) {
//
// Delay an anonymous method definition to avoid emitting unused code
// for unreachable blocks or expression trees
//
method = DoCreateMethodHost (ec);
method.Define ();
}
bool is_static = (method.ModFlags & Modifiers.STATIC) != 0;
if (is_static && am_cache == null) {
//
// Creates a field cache to store delegate instance if it's not generic
//
if (!method.MemberName.IsGeneric) {
var parent = method.Parent.PartialContainer;
int id = parent.AnonymousMethodsCounter++;
var cache_type = storey != null && storey.Mutator != null ? storey.Mutator.Mutate (type) : type;
am_cache = new Field (parent, new TypeExpression (cache_type, loc),
Modifiers.STATIC | Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED,
new MemberName (CompilerGeneratedContainer.MakeName (null, "f", "am$cache", id), loc), null);
am_cache.Define ();
parent.AddField (am_cache);
} else {
// TODO: Implement caching of generated generic static methods
//
// Idea:
//
// Some extra class is needed to capture variable generic type
// arguments. Maybe we could re-use anonymous types, with a unique
// anonymous method id, but they are quite heavy.
//
// Consider : "() => typeof(T);"
//
// We need something like
// static class Wrap<Tn, Tm, DelegateType> {
// public static DelegateType cache;
// }
//
// We then specialize local variable to capture all generic parameters
// and delegate type, e.g. "Wrap<Ta, Tb, DelegateTypeInst> cache;"
//
}
}
Label l_initialized = ec.DefineLabel ();
if (am_cache != null) {
ec.Emit (OpCodes.Ldsfld, am_cache.Spec);
ec.Emit (OpCodes.Brtrue_S, l_initialized);
}
//
// Load method delegate implementation
//
if (is_static) {
ec.EmitNull ();
} else if (storey != null) {
Expression e = storey.GetStoreyInstanceExpression (ec).Resolve (new ResolveContext (ec.MemberContext));
if (e != null) {
e.Emit (ec);
}
} else {
ec.EmitThis ();
//
// Special case for value type storey where this is not lifted but
// droped off to parent class
//
for (var b = Block.Parent; b != null; b = b.Parent) {
if (b.ParametersBlock.StateMachine != null) {
ec.Emit (OpCodes.Ldfld, b.ParametersBlock.StateMachine.HoistedThis.Field.Spec);
break;
}
}
}
var delegate_method = method.Spec;
if (storey != null && storey.MemberName.IsGeneric) {
TypeSpec t = storey.Instance.Type;
//
// Mutate anonymous method instance type if we are in nested
// hoisted generic anonymous method storey
//
if (ec.IsAnonymousStoreyMutateRequired) {
t = storey.Mutator.Mutate (t);
}
ec.Emit (OpCodes.Ldftn, TypeBuilder.GetMethod (t.GetMetaInfo (), (MethodInfo) delegate_method.GetMetaInfo ()));
} else {
if (delegate_method.IsGeneric)
delegate_method = delegate_method.MakeGenericMethod (ec.MemberContext, method.TypeParameters);
ec.Emit (OpCodes.Ldftn, delegate_method);
}
var constructor_method = Delegate.GetConstructor (type);
ec.Emit (OpCodes.Newobj, constructor_method);
if (am_cache != null) {
ec.Emit (OpCodes.Stsfld, am_cache.Spec);
ec.MarkLabel (l_initialized);
ec.Emit (OpCodes.Ldsfld, am_cache.Spec);
}
}
