public override Expression EmitToField(EmitContext ec)
{
return(child.EmitToField(ec));
}
public void EmitPredefined(EmitContext ec, MethodSpec method, Arguments Arguments, Location?loc = null)
{
Expression instance_copy = null;
if (!HasAwaitArguments && ec.HasSet(BuilderContext.Options.AsyncBody))
{
HasAwaitArguments = Arguments != null && Arguments.ContainsEmitWithAwait();
if (HasAwaitArguments && InstanceExpressionOnStack)
{
throw new NotSupportedException();
}
}
OpCode call_op;
LocalTemporary lt = null;
if (method.IsStatic)
{
call_op = OpCodes.Call;
}
else
{
if (IsVirtualCallRequired(InstanceExpression, method))
{
call_op = OpCodes.Callvirt;
}
else
{
call_op = OpCodes.Call;
}
if (HasAwaitArguments)
{
instance_copy = InstanceExpression.EmitToField(ec);
if (Arguments == null)
{
EmitCallInstance(ec, instance_copy, method.DeclaringType, call_op);
}
}
else if (!InstanceExpressionOnStack)
{
var instance_on_stack_type = EmitCallInstance(ec, InstanceExpression, method.DeclaringType, call_op);
if (DuplicateArguments)
{
ec.Emit(OpCodes.Dup);
if (Arguments != null && Arguments.Count != 0)
{
lt = new LocalTemporary(instance_on_stack_type);
lt.Store(ec);
instance_copy = lt;
}
}
}
}
if (Arguments != null && !InstanceExpressionOnStack)
{
EmittedArguments = Arguments.Emit(ec, DuplicateArguments, HasAwaitArguments);
if (EmittedArguments != null)
{
if (instance_copy != null)
{
EmitCallInstance(ec, instance_copy, method.DeclaringType, call_op);
if (lt != null)
{
lt.Release(ec);
}
}
EmittedArguments.Emit(ec);
}
}
if (call_op == OpCodes.Callvirt && (InstanceExpression.Type.IsGenericParameter || InstanceExpression.Type.IsStructOrEnum))
{
ec.Emit(OpCodes.Constrained, InstanceExpression.Type);
}
if (loc != null)
{
//
// Emit explicit sequence point for expressions like Foo.Bar () to help debugger to
// break at right place when LHS expression can be stepped-into
//
ec.MarkCallEntry(loc.Value);
}
//
// Set instance expression to actual result expression. When it contains await it can be
// picked up by caller
//
InstanceExpression = instance_copy;
if (method.Parameters.HasArglist)
{
var varargs_types = GetVarargsTypes(method, Arguments);
ec.Emit(call_op, method, varargs_types);
return;
}
//
// If you have:
// this.DoFoo ();
// and DoFoo is not virtual, you can omit the callvirt,
// because you don't need the null checking behavior.
//
ec.Emit(call_op, method);
}
public Argument EmitToField(EmitContext ec)
{
var res = Expr.EmitToField(ec);
return(res == Expr ? this : new Argument(res, ArgType));
}
