//
// Creates an invoke call on invocable expression
//
public override System.Linq.Expressions.Expression MakeExpression(Compiler.BuilderContext ctx)
{
var invokeBinder = invoke.invokeBinder;
var binder = Binder.Invoke(invokeBinder.flags, invokeBinder.callingContext, invokeBinder.argumentInfo);
var args = invoke.Arguments;
var args_expr = new SLE.Expression[invokeBinder.argumentInfo.Count];
var types = new Type [args_expr.Length + 2];
// Required by MakeDynamic
types[0] = typeof(System.Runtime.CompilerServices.CallSite);
types[1] = expr.Type.GetMetaInfo();
args_expr[0] = expr.MakeExpression(ctx);
for (int i = 0; i < args.Count; ++i)
{
args_expr[i + 1] = args[i].Expr.MakeExpression(ctx);
int type_index = i + 2;
types[type_index] = args[i].Type.GetMetaInfo();
if (args[i].IsByRef)
{
types[type_index] = types[type_index].MakeByRefType();
}
}
// Return type goes last
bool void_result = (invokeBinder.flags & CSharpBinderFlags.ResultDiscarded) != 0;
types[types.Length - 1] = void_result ? typeof(void) : invokeBinder.ReturnType;
//
// Much easier to use Expression.Dynamic cannot be used because it ignores ByRef arguments
// and it always generates either Func or Action and any value type argument is lost
//
Type delegateType = SLE.Expression.GetDelegateType(types);
return(SLE.Expression.MakeDynamic(delegateType, binder, args_expr));
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return SLE.Expression.Block (expr.MakeExpression (ctx), SLE.Expression.Default (type.GetMetaInfo ()));
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return System.Linq.Expressions.Expression.Constant (GetValue ());
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
return SLE.Expression.Block (expr.MakeExpression (ctx), SLE.Expression.Default (type.GetMetaInfo ()));
#endif
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
if (typed && obj.Expression.Type != type)
return System.Linq.Expressions.Expression.Convert (obj.Expression, type);
return obj.Expression;
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return orig_expr.MakeExpression (ctx);
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return SLE.Expression.Field (InstanceExpression.MakeExpression (ctx), spec.GetMetaInfo ());
}
internal FlagsHandle (BuilderContext ec, Options mask, Options val)
{
this.ec = ec;
invmask = ~mask;
oldval = ec.flags & mask;
ec.flags = (ec.flags & invmask) | (val & mask);
}
public override System.Linq.Expressions.Expression MakeExpression(BuilderContext ctx)
{
return(System.Linq.Expressions.Expression.Constant(null));
}
public static System.Linq.Expressions.Expression[] MakeExpression(Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
{
return(null);
}
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i)
{
Argument a = args.args [i];
exprs[i] = a.Expr.MakeExpression(ctx);
}
return(exprs);
}
public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
return null;
// TODO: implement
if (args.reordered != null)
throw new NotImplementedException ();
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i) {
Argument a = (Argument) args.args [i];
exprs[i] = a.Expr.MakeExpression (ctx);
}
return exprs;
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return(MakeExpression(ctx, mg.InstanceExpression, mg.BestCandidate, arguments));
}
public static System.Linq.Expressions.Expression[] MakeExpression(Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
{
return(null);
}
// TODO: implement
if (args.reordered != null)
{
throw new NotImplementedException();
}
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i)
{
Argument a = (Argument)args.args [i];
exprs[i] = a.Expr.MakeExpression(ctx);
}
return(exprs);
}
public static SLE.Expression MakeExpression (BuilderContext ctx, Expression instance, MethodSpec mi, Arguments args)
{
#if STATIC
throw new NotSupportedException ();
#else
var instance_expr = instance == null ? null : instance.MakeExpression (ctx);
return SLE.Expression.Call (instance_expr, (MethodInfo) mi.GetMetaInfo (), Arguments.MakeExpression (args, ctx));
#endif
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return SLE.Expression.Convert (obj.Expression, type.GetMetaInfo ());
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return System.Linq.Expressions.Expression.Constant (GetTypedValue (), type.GetMetaInfo ());
}
public SLE.Expression MakeAssignExpression(BuilderContext ctx, Expression source)
{
return(obj.Expression);
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
return MakeExpression (ctx, mg.InstanceExpression, mg.BestCandidate, arguments);
}
public override System.Linq.Expressions.Expression MakeExpression(BuilderContext ctx)
{
return(Invocation.MakeExpression(ctx, InstanceExpr, method, arguments));
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return SLE.Expression.Property (InstanceExpression.MakeExpression (ctx), (MethodInfo) spec.Get.GetMetaInfo ());
}
public FlagsHandle(BuilderContext ec, Options flagsToSet)
: this(ec, flagsToSet, flagsToSet)
{
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return ctx.HasSet (BuilderContext.Options.CheckedScope) ?
SLE.Expression.ConvertChecked (child.MakeExpression (ctx), type.GetMetaInfo ()) :
SLE.Expression.Convert (child.MakeExpression (ctx), type.GetMetaInfo ());
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
var le = left.MakeExpression (ctx);
var re = right.MakeExpression (ctx);
bool is_checked = ctx.HasSet (BuilderContext.Options.CheckedScope);
switch (oper) {
case Operator.Addition:
return is_checked ? SLE.Expression.AddChecked (le, re) : SLE.Expression.Add (le, re);
case Operator.BitwiseAnd:
return SLE.Expression.And (le, re);
case Operator.BitwiseOr:
return SLE.Expression.Or (le, re);
case Operator.Division:
return SLE.Expression.Divide (le, re);
case Operator.Equality:
return SLE.Expression.Equal (le, re);
case Operator.ExclusiveOr:
return SLE.Expression.ExclusiveOr (le, re);
case Operator.GreaterThan:
return SLE.Expression.GreaterThan (le, re);
case Operator.GreaterThanOrEqual:
return SLE.Expression.GreaterThanOrEqual (le, re);
case Operator.Inequality:
return SLE.Expression.NotEqual (le, re);
case Operator.LeftShift:
return SLE.Expression.LeftShift (le, re);
case Operator.LessThan:
return SLE.Expression.LessThan (le, re);
case Operator.LessThanOrEqual:
return SLE.Expression.LessThanOrEqual (le, re);
case Operator.LogicalAnd:
return SLE.Expression.AndAlso (le, re);
case Operator.LogicalOr:
return SLE.Expression.OrElse (le, re);
case Operator.Modulus:
return SLE.Expression.Modulo (le, re);
case Operator.Multiply:
return is_checked ? SLE.Expression.MultiplyChecked (le, re) : SLE.Expression.Multiply (le, re);
case Operator.RightShift:
return SLE.Expression.RightShift (le, re);
case Operator.Subtraction:
return is_checked ? SLE.Expression.SubtractChecked (le, re) : SLE.Expression.Subtract (le, re);
default:
throw new NotImplementedException (oper.ToString ());
}
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
if (type.IsStruct && !obj.Expression.Type.IsValueType)
return SLE.Expression.Unbox (obj.Expression, type.GetMetaInfo ());
if (obj.Expression.NodeType == SLE.ExpressionType.Parameter) {
if (((SLE.ParameterExpression) obj.Expression).IsByRef)
return obj.Expression;
}
return SLE.Expression.Convert (obj.Expression, type.GetMetaInfo ());
#endif
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
if (arguments.Count != 2)
throw new NotImplementedException ("arguments.Count != 2");
var concat = TypeManager.string_type.GetMethod ("Concat", new[] { typeof (object), typeof (object) });
return SLE.Expression.Add (arguments[0].Expr.MakeExpression (ctx), arguments[1].Expr.MakeExpression (ctx), concat);
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return Invocation.MakeExpression (ctx, InstanceExpr, method, arguments);
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
return SLE.Expression.Call ((MethodInfo) mg, Arguments.MakeExpression (arguments, ctx));
}
public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
return null;
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i) {
Argument a = args.args [i];
exprs[i] = a.Expr.MakeExpression (ctx);
}
return exprs;
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
using (ctx.With (BuilderContext.Options.AllCheckStateFlags, true)) {
return Expr.MakeExpression (ctx);
}
}
public SLE.Expression MakeAssignExpression(BuilderContext ctx)
{
return obj.Expression;
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
return SLE.Expression.Convert (source.MakeExpression (ctx), type, method);
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
var tassign = target as IDynamicAssign;
if (tassign == null)
throw new InternalErrorException (target.GetType () + " does not support dynamic assignment");
var target_object = tassign.MakeAssignExpression (ctx, source);
//
// Some hacking is needed as DLR does not support void type and requires
// always have object convertible return type to support caching and chaining
//
// We do this by introducing an explicit block which returns RHS value when
// available or null
//
if (target_object.NodeType == System.Linq.Expressions.ExpressionType.Block)
return target_object;
System.Linq.Expressions.UnaryExpression source_object;
if (ctx.HasSet (BuilderContext.Options.CheckedScope)) {
source_object = System.Linq.Expressions.Expression.ConvertChecked (source.MakeExpression (ctx), target_object.Type);
} else {
source_object = System.Linq.Expressions.Expression.Convert (source.MakeExpression (ctx), target_object.Type);
}
return System.Linq.Expressions.Expression.Assign (target_object, source_object);
}
//
// Implemented by all expressions which support conversion from
// compiler expression to invokable runtime expression. Used by
// dynamic C# binder.
//
public virtual SLE.Expression MakeExpression(BuilderContext ctx)
{
throw new NotImplementedException ("MakeExpression for " + GetType ());
}
public FlagsHandle (BuilderContext ec, Options flagsToSet)
: this (ec, flagsToSet, flagsToSet)
{
}
public SLE.Expression MakeAssignExpression(BuilderContext ctx)
{
return MakeExpression (ctx);
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
return System.Linq.Expressions.Expression.Constant (GetTypedValue (), type.GetMetaInfo ());
#endif
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
var target_object = target.MakeExpression (ctx);
var source_object = System.Linq.Expressions.Expression.Convert (source.MakeExpression (ctx), target_object.Type);
return System.Linq.Expressions.Expression.Assign (target_object, source_object);
}