protected override Expression CreateExpressionTree (ResolveContext ec, TypeSpec delegate_type)
{
if (ec.IsInProbingMode)
return this;
BlockContext bc = new BlockContext (ec.MemberContext, ec.ConstructorBlock, ec.BuiltinTypes.Void) {
CurrentAnonymousMethod = ec.CurrentAnonymousMethod
};
Expression args = Parameters.CreateExpressionTree (bc, loc);
Expression expr = Block.CreateExpressionTree (ec);
if (expr == null)
return null;
Arguments arguments = new Arguments (2);
arguments.Add (new Argument (expr));
arguments.Add (new Argument (args));
return CreateExpressionFactoryCall (ec, "Lambda",
new TypeArguments (new TypeExpression (delegate_type, loc)),
arguments);
}
protected override Arguments CreateSetterArguments (ResolveContext rc, Expression rhs)
{
//
// Indexer has arguments which complicates things as the setter and getter
// are called in two steps when unary mutator is used. We have to make a
// copy of all variable arguments to not duplicate any side effect.
//
// ++d[++arg, Foo ()]
//
if (!can_be_mutator)
return base.CreateSetterArguments (rc, rhs);
var setter_args = new Arguments (Arguments.Count + 1);
for (int i = 0; i < Arguments.Count; ++i) {
var expr = Arguments[i].Expr;
if (expr is Constant || expr is VariableReference || expr is This) {
setter_args.Add (Arguments [i]);
continue;
}
LocalVariable temp = LocalVariable.CreateCompilerGenerated (expr.Type, rc.CurrentBlock, loc);
expr = new SimpleAssign (temp.CreateReferenceExpression (rc, expr.Location), expr).Resolve (rc);
Arguments[i].Expr = temp.CreateReferenceExpression (rc, expr.Location).Resolve (rc);
setter_args.Add (Arguments [i].Clone (expr));
}
setter_args.Add (new Argument (rhs));
return setter_args;
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (3);
flags |= ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new TypeOf (type, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
return new Invocation (GetBinder ("Convert", loc), binder_args);
}
protected void EmitCall (EmitContext ec, Expression binder, Arguments arguments, bool isStatement)
{
//
// This method generates all internal infrastructure for a dynamic call. The
// reason why it's quite complicated is the mixture of dynamic and anonymous
// methods. Dynamic itself requires a temporary class (ContainerX) and anonymous
// methods can generate temporary storey as well (AnonStorey). Handling MVAR
// type parameters rewrite is non-trivial in such case as there are various
// combinations possible therefore the mutator is not straightforward. Secondly
// we need to keep both MVAR(possibly VAR for anon storey) and type VAR to emit
// correct Site field type and its access from EmitContext.
//
int dyn_args_count = arguments == null ? 0 : arguments.Count;
int default_args = isStatement ? 1 : 2;
var module = ec.Module;
bool has_ref_out_argument = false;
var targs = new TypeExpression[dyn_args_count + default_args];
targs[0] = new TypeExpression (module.PredefinedTypes.CallSite.TypeSpec, loc);
TypeExpression[] targs_for_instance = null;
TypeParameterMutator mutator;
var site_container = ec.CreateDynamicSite ();
if (context_mvars != null) {
TypeParameters tparam;
TypeContainer sc = site_container;
do {
tparam = sc.CurrentTypeParameters;
sc = sc.Parent;
} while (tparam == null);
mutator = new TypeParameterMutator (context_mvars, tparam);
if (!ec.IsAnonymousStoreyMutateRequired) {
targs_for_instance = new TypeExpression[targs.Length];
targs_for_instance[0] = targs[0];
}
} else {
mutator = null;
}
for (int i = 0; i < dyn_args_count; ++i) {
Argument a = arguments[i];
if (a.ArgType == Argument.AType.Out || a.ArgType == Argument.AType.Ref)
has_ref_out_argument = true;
var t = a.Type;
// Convert any internal type like dynamic or null to object
if (t.Kind == MemberKind.InternalCompilerType)
t = ec.BuiltinTypes.Object;
if (targs_for_instance != null)
targs_for_instance[i + 1] = new TypeExpression (t, loc);
if (mutator != null)
t = t.Mutate (mutator);
targs[i + 1] = new TypeExpression (t, loc);
}
TypeExpr del_type = null;
TypeExpr del_type_instance_access = null;
if (!has_ref_out_argument) {
string d_name = isStatement ? "Action" : "Func";
TypeExpr te = null;
Namespace type_ns = module.GlobalRootNamespace.GetNamespace ("System", true);
if (type_ns != null) {
te = type_ns.LookupType (module, d_name, dyn_args_count + default_args, LookupMode.Normal, loc);
}
if (te != null) {
if (!isStatement) {
var t = type;
if (t.Kind == MemberKind.InternalCompilerType)
t = ec.BuiltinTypes.Object;
if (targs_for_instance != null)
targs_for_instance[targs_for_instance.Length - 1] = new TypeExpression (t, loc);
if (mutator != null)
t = t.Mutate (mutator);
targs[targs.Length - 1] = new TypeExpression (t, loc);
}
del_type = new GenericTypeExpr (te.Type, new TypeArguments (targs), loc);
if (targs_for_instance != null)
del_type_instance_access = new GenericTypeExpr (te.Type, new TypeArguments (targs_for_instance), loc);
else
del_type_instance_access = del_type;
}
}
//
// Create custom delegate when no appropriate predefined delegate has been found
//
Delegate d;
if (del_type == null) {
TypeSpec rt = isStatement ? ec.BuiltinTypes.Void : type;
Parameter[] p = new Parameter[dyn_args_count + 1];
p[0] = new Parameter (targs[0], "p0", Parameter.Modifier.NONE, null, loc);
var site = ec.CreateDynamicSite ();
int index = site.Containers == null ? 0 : site.Containers.Count;
if (mutator != null)
rt = mutator.Mutate (rt);
for (int i = 1; i < dyn_args_count + 1; ++i) {
p[i] = new Parameter (targs[i], "p" + i.ToString ("X"), arguments[i - 1].Modifier, null, loc);
}
d = new Delegate (site, new TypeExpression (rt, loc),
Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED,
new MemberName ("Container" + index.ToString ("X")),
new ParametersCompiled (p), null);
d.CreateContainer ();
d.DefineContainer ();
d.Define ();
site.AddTypeContainer (d);
del_type = new TypeExpression (d.CurrentType, loc);
if (targs_for_instance != null) {
del_type_instance_access = null;
} else {
del_type_instance_access = del_type;
}
} else {
d = null;
}
var site_type_decl = new GenericTypeExpr (module.PredefinedTypes.CallSiteGeneric.TypeSpec, new TypeArguments (del_type), loc);
var field = site_container.CreateCallSiteField (site_type_decl, loc);
if (field == null)
return;
if (del_type_instance_access == null) {
var dt = d.CurrentType.DeclaringType.MakeGenericType (module, context_mvars.Types);
del_type_instance_access = new TypeExpression (MemberCache.GetMember (dt, d.CurrentType), loc);
}
var instanceAccessExprType = new GenericTypeExpr (module.PredefinedTypes.CallSiteGeneric.TypeSpec,
new TypeArguments (del_type_instance_access), loc);
if (instanceAccessExprType.ResolveAsType (ec.MemberContext) == null)
return;
bool inflate_using_mvar = context_mvars != null && ec.IsAnonymousStoreyMutateRequired;
TypeSpec gt;
if (inflate_using_mvar || context_mvars == null) {
gt = site_container.CurrentType;
} else {
gt = site_container.CurrentType.MakeGenericType (module, context_mvars.Types);
}
// When site container already exists the inflated version has to be
// updated manually to contain newly created field
if (gt is InflatedTypeSpec && site_container.AnonymousMethodsCounter > 1) {
var tparams = gt.MemberDefinition.TypeParametersCount > 0 ? gt.MemberDefinition.TypeParameters : TypeParameterSpec.EmptyTypes;
var inflator = new TypeParameterInflator (module, gt, tparams, gt.TypeArguments);
gt.MemberCache.AddMember (field.InflateMember (inflator));
}
FieldExpr site_field_expr = new FieldExpr (MemberCache.GetMember (gt, field), loc);
BlockContext bc = new BlockContext (ec.MemberContext, null, ec.BuiltinTypes.Void);
Arguments args = new Arguments (1);
args.Add (new Argument (binder));
StatementExpression s = new StatementExpression (new SimpleAssign (site_field_expr, new Invocation (new MemberAccess (instanceAccessExprType, "Create"), args)));
using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
if (s.Resolve (bc)) {
Statement init = new If (new Binary (Binary.Operator.Equality, site_field_expr, new NullLiteral (loc)), s, loc);
init.Emit (ec);
}
args = new Arguments (1 + dyn_args_count);
args.Add (new Argument (site_field_expr));
if (arguments != null) {
int arg_pos = 1;
foreach (Argument a in arguments) {
if (a is NamedArgument) {
// Name is not valid in this context
args.Add (new Argument (a.Expr, a.ArgType));
} else {
args.Add (a);
}
if (inflate_using_mvar && a.Type != targs[arg_pos].Type)
a.Expr.Type = targs[arg_pos].Type;
++arg_pos;
}
}
Expression target = new DelegateInvocation (new MemberAccess (site_field_expr, "Target", loc).Resolve (bc), args, loc).Resolve (bc);
if (target != null)
target.Emit (ec);
}
}
public static Arguments CreateForExpressionTree (ResolveContext ec, Arguments args, params Expression[] e)
{
Arguments all = new Arguments ((args == null ? 0 : args.Count) + e.Length);
for (int i = 0; i < e.Length; ++i) {
if (e [i] != null)
all.Add (new Argument (e[i]));
}
if (args != null) {
foreach (Argument a in args.args) {
Expression tree_arg = a.CreateExpressionTree (ec);
if (tree_arg != null)
all.Add (new Argument (tree_arg));
}
}
return all;
}
protected override Expression DoResolve (ResolveContext ec)
{
if (ec.Target == Target.JavaScript) {
expr = Expr.Resolve (ec);
objExpr = objExpr.Resolve (ec);
type = ec.BuiltinTypes.Bool;
eclass = ExprClass.Value;
return this;
}
var objExpRes = objExpr.Resolve (ec);
var args = new Arguments (1);
args.Add (new Argument (expr));
if (objExpRes.Type == ec.BuiltinTypes.Dynamic) {
// If dynamic, cast to IDictionary<string,object> and call ContainsKey
var dictExpr = new TypeExpression(ec.Module.PredefinedTypes.IDictionaryGeneric.Resolve().MakeGenericType(ec,
new [] { ec.BuiltinTypes.String, ec.BuiltinTypes.Object }), loc);
return new Invocation (new MemberAccess (new Cast(dictExpr, objExpr, loc), "ContainsKey", loc), args).Resolve (ec);
} else {
string containsMethodName = "Contains";
if (objExpRes.Type != null && objExpRes.Type.ImplementsInterface (ec.Module.PredefinedTypes.IDictionary.Resolve(), true)) {
containsMethodName = "ContainsKey";
}
return new Invocation (new MemberAccess (objExpr, containsMethodName, loc), args).Resolve (ec);
}
}
protected override Expression DoResolve (ResolveContext rc)
{
if (rc.Target == Target.JavaScript) {
type = rc.Module.PredefinedTypes.AsRegExp.Resolve();
eclass = ExprClass.Value;
return this;
}
var args = new Arguments(2);
args.Add (new Argument(new StringLiteral(rc.BuiltinTypes, Regex, this.Location)));
args.Add (new Argument(new StringLiteral(rc.BuiltinTypes, Options, this.Location)));
return new New(new TypeExpression(rc.Module.PredefinedTypes.AsRegExp.Resolve(), this.Location),
args, this.Location).Resolve (rc);
}
protected override Expression DoResolve(ResolveContext ec)
{
// if (ec.Target == Target.JavaScript) {
// type = ec.BuiltinTypes.Dynamic;
// eclass = ExprClass.Value;
// return this;
// }
if (Expr is ElementAccess)
{
var elem_access = Expr as ElementAccess;
if (elem_access.Arguments.Count != 1)
{
ec.Report.Error(7021, loc, "delete statement must have only one index argument.");
return(null);
}
var expr = elem_access.Expr.Resolve(ec);
if (expr.Type == null)
{
return(null);
}
if (expr.Type.IsArray)
{
ec.Report.Error(7021, loc, "delete statement not allowed on arrays.");
return(null);
}
if (ec.Target == Target.JavaScript)
{
Expr = Expr.Resolve(ec);
return(this);
}
removeExpr = new Invocation(new MemberAccess(expr, "Remove", loc), elem_access.Arguments);
return(removeExpr.Resolve(ec));
}
else if (Expr is MemberAccess)
{
if (ec.Target == Target.JavaScript)
{
Expr = Expr.Resolve(ec);
return(this);
}
var memb_access = Expr as MemberAccess;
var expr = memb_access.LeftExpression.Resolve(ec);
if (expr.Type == null)
{
return(null);
}
var args = new Arguments(1);
args.Add(new Argument(new StringLiteral(ec.BuiltinTypes, memb_access.Name, loc)));
removeExpr = new Invocation(new MemberAccess(expr, "Remove", loc), args);
return(removeExpr.Resolve(ec));
}
else
{
// Error is reported elsewhere.
return(null);
}
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
if (type == InternalType.NullLiteral || type.BuiltinType == BuiltinTypeSpec.Type.Object) {
// Optimized version, also avoids referencing literal internal type
Arguments args = new Arguments (1);
args.Add (new Argument (this));
return CreateExpressionFactoryCall (ec, "Constant", args);
}
return base.CreateExpressionTree (ec);
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
BlockContext bc = new BlockContext (ec.MemberContext, Block, ReturnType);
Expression args = parameters.CreateExpressionTree (bc, loc);
Expression expr = Block.CreateExpressionTree (ec);
if (expr == null)
return null;
Arguments arguments = new Arguments (2);
arguments.Add (new Argument (expr));
arguments.Add (new Argument (args));
return CreateExpressionFactoryCall (ec, "Lambda",
new TypeArguments (new TypeExpression (type, loc)),
arguments);
}
void case_483()
#line 3517 "cs-parser.jay"
{
Arguments args = new Arguments (4);
args.Add ((Argument) yyVals[0+yyTop]);
yyVal = args;
}
protected override bool DoDefineMembers()
{
PredefinedType builder_type;
PredefinedMember <MethodSpec> bf;
PredefinedMember <MethodSpec> bs;
PredefinedMember <MethodSpec> sr;
PredefinedMember <MethodSpec> se;
PredefinedMember <MethodSpec> sm;
bool has_task_return_type = false;
var pred_members = Module.PredefinedMembers;
if (return_type.Kind == MemberKind.Void)
{
builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
bf = pred_members.AsyncVoidMethodBuilderCreate;
bs = pred_members.AsyncVoidMethodBuilderStart;
sr = pred_members.AsyncVoidMethodBuilderSetResult;
se = pred_members.AsyncVoidMethodBuilderSetException;
sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
}
else if (return_type == Module.PredefinedTypes.Task.TypeSpec)
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
bf = pred_members.AsyncTaskMethodBuilderCreate;
bs = pred_members.AsyncTaskMethodBuilderStart;
sr = pred_members.AsyncTaskMethodBuilderSetResult;
se = pred_members.AsyncTaskMethodBuilderSetException;
sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderTask.Get();
}
else
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
bs = pred_members.AsyncTaskMethodBuilderGenericStart;
sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
se = pred_members.AsyncTaskMethodBuilderGenericSetException;
sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderGenericTask.Get();
has_task_return_type = true;
}
set_result = sr.Get();
set_exception = se.Get();
builder_factory = bf.Get();
builder_start = bs.Get();
var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
var set_statemachine = sm.Get();
if (!builder_type.Define() || !istate_machine.Define() || set_result == null || builder_factory == null ||
set_exception == null || set_statemachine == null || builder_start == null ||
!Module.PredefinedTypes.INotifyCompletion.Define())
{
Report.Error(1993, Location,
"Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
return(base.DoDefineMembers());
}
var bt = builder_type.TypeSpec;
//
// Inflate generic Task types
//
if (has_task_return_type)
{
var task_return_type = return_type.TypeArguments;
if (mutator != null)
{
task_return_type = mutator.Mutate(task_return_type);
}
bt = bt.MakeGenericType(Module, task_return_type);
set_result = MemberCache.GetMember(bt, set_result);
set_exception = MemberCache.GetMember(bt, set_exception);
set_statemachine = MemberCache.GetMember(bt, set_statemachine);
if (task != null)
{
task = MemberCache.GetMember(bt, task);
}
}
builder = AddCompilerGeneratedField("$builder", new TypeExpression(bt, Location));
var set_state_machine = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Void, Location),
Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
new MemberName("SetStateMachine"),
ParametersCompiled.CreateFullyResolved(
new Parameter(new TypeExpression(istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
istate_machine.TypeSpec),
null);
ToplevelBlock block = new ToplevelBlock(Compiler, set_state_machine.ParameterInfo, Location);
block.IsCompilerGenerated = true;
set_state_machine.Block = block;
Members.Add(set_state_machine);
if (!base.DoDefineMembers())
{
return(false);
}
//
// Fabricates SetStateMachine method
//
// public void SetStateMachine (IAsyncStateMachine stateMachine)
// {
// $builder.SetStateMachine (stateMachine);
// }
//
var mg = MethodGroupExpr.CreatePredefined(set_statemachine, bt, Location);
mg.InstanceExpression = new FieldExpr(builder, Location);
var param_reference = block.GetParameterReference(0, Location);
param_reference.Type = istate_machine.TypeSpec;
param_reference.eclass = ExprClass.Variable;
var args = new Arguments(1);
args.Add(new Argument(param_reference));
set_state_machine.Block.AddStatement(new StatementExpression(new Invocation(mg, args)));
if (has_task_return_type)
{
hoisted_return = LocalVariable.CreateCompilerGenerated(bt.TypeArguments[0], StateMachineMethod.Block, Location);
}
return(true);
}
public void EmitPrologue(EmitContext ec)
{
awaiter = ((AsyncTaskStorey)machine_initializer.Storey).AddAwaiter(expr.Type, loc);
var fe_awaiter = new FieldExpr(awaiter, loc);
fe_awaiter.InstanceExpression = new CompilerGeneratedThis(ec.CurrentType, loc);
//
// awaiter = expr.GetAwaiter ();
//
using (ec.With(BuilderContext.Options.OmitDebugInfo, true)) {
fe_awaiter.EmitAssign(ec, expr, false, false);
}
Label skip_continuation = ec.DefineLabel();
Expression completed_expr;
if (IsDynamic)
{
var rc = new ResolveContext(ec.MemberContext);
Arguments dargs = new Arguments(1);
dargs.Add(new Argument(fe_awaiter));
completed_expr = new DynamicMemberBinder("IsCompleted", dargs, loc).Resolve(rc);
dargs = new Arguments(1);
dargs.Add(new Argument(completed_expr));
completed_expr = new DynamicConversion(ec.Module.Compiler.BuiltinTypes.Bool, 0, dargs, loc).Resolve(rc);
}
else
{
var pe = PropertyExpr.CreatePredefined(awaiter_definition.IsCompleted, loc);
pe.InstanceExpression = fe_awaiter;
completed_expr = pe;
}
completed_expr.EmitBranchable(ec, skip_continuation, true);
base.DoEmit(ec);
//
// The stack has to be empty before calling await continuation. We handle this
// by lifting values which would be left on stack into class fields. The process
// is quite complicated and quite hard to test because any expression can possibly
// leave a value on the stack.
//
// Following assert fails when some of expression called before is missing EmitToField
// or parent expression fails to find await in children expressions
//
ec.AssertEmptyStack();
var storey = (AsyncTaskStorey)machine_initializer.Storey;
if (IsDynamic)
{
storey.EmitAwaitOnCompletedDynamic(ec, fe_awaiter);
}
else
{
storey.EmitAwaitOnCompleted(ec, fe_awaiter);
}
// Return ok
machine_initializer.EmitLeave(ec, unwind_protect);
ec.MarkLabel(resume_point);
ec.MarkLabel(skip_continuation);
}
protected override Expression CreateCallSiteBinder (ResolveContext ec, Arguments args, bool isSet)
{
Arguments binder_args = new Arguments (4);
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
isSet |= (flags & CSharpBinderFlags.ValueFromCompoundAssignment) != 0;
return new Invocation (GetBinder (isSet ? "SetMember" : "GetMember", loc), binder_args);
}
public static Arguments CreateDelegateMethodArguments (ResolveContext rc, AParametersCollection pd, TypeSpec[] types, Location loc)
{
Arguments delegate_arguments = new Arguments (pd.Count);
for (int i = 0; i < pd.Count; ++i) {
Argument.AType atype_modifier;
switch (pd.FixedParameters [i].ModFlags) {
case Parameter.Modifier.REF:
atype_modifier = Argument.AType.Ref;
break;
case Parameter.Modifier.OUT:
atype_modifier = Argument.AType.Out;
break;
default:
atype_modifier = 0;
break;
}
var ptype = types[i];
if (ptype.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
ptype = rc.BuiltinTypes.Object;
delegate_arguments.Add (new Argument (new TypeExpression (ptype, loc), atype_modifier));
}
return delegate_arguments;
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (4);
MemberAccess sle = new MemberAccess (new MemberAccess (
new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Linq", loc), "Expressions", loc);
var flags = ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
return new Invocation (GetBinder ("UnaryOperation", loc), binder_args);
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
MemberAccess ma = new MemberAccess (new MemberAccess (new QualifiedAliasMember ("global", "System", loc), "Delegate", loc), "CreateDelegate", loc);
Arguments args = new Arguments (3);
args.Add (new Argument (new TypeOf (type, loc)));
if (method_group.InstanceExpression == null)
args.Add (new Argument (new NullLiteral (loc)));
else
args.Add (new Argument (method_group.InstanceExpression));
args.Add (new Argument (method_group.CreateExpressionTree (ec)));
Expression e = new Invocation (ma, args).Resolve (ec);
if (e == null)
return null;
e = Convert.ExplicitConversion (ec, e, type, loc);
if (e == null)
return null;
return e.CreateExpressionTree (ec);
}
protected override Expression DoResolve (ResolveContext ec)
{
if (ec.Target == Target.JavaScript) {
type = ec.BuiltinTypes.Dynamic;
eclass = ExprClass.Value;
return this;
}
if (loc.SourceFile != null && loc.SourceFile.PsExtended) {
ec.Report.Error (7101, loc, "'typeof' operator not supported in ASX.'");
return null;
}
var args = new Arguments(1);
args.Add (new Argument(Expr));
return new Invocation(new MemberAccess(new MemberAccess(
new SimpleName(PsConsts.PsRootNamespace, loc), "_typeof_fn", loc), "_typeof", loc), args).Resolve (ec);
}
void FabricateBodyStatement ()
{
//
// Delegate obj1 = backing_field
// do {
// Delegate obj2 = obj1;
// obj1 = Interlocked.CompareExchange (ref backing_field, Delegate.Combine|Remove(obj2, value), obj1);
// } while ((object)obj1 != (object)obj2)
//
var field_info = ((EventField) method).backing_field;
FieldExpr f_expr = new FieldExpr (field_info, Location);
if (!IsStatic)
f_expr.InstanceExpression = new CompilerGeneratedThis (Parent.CurrentType, Location);
var obj1 = LocalVariable.CreateCompilerGenerated (field_info.MemberType, block, Location);
var obj2 = LocalVariable.CreateCompilerGenerated (field_info.MemberType, block, Location);
block.AddStatement (new StatementExpression (new SimpleAssign (new LocalVariableReference (obj1, Location), f_expr)));
var cond = new BooleanExpression (new Binary (Binary.Operator.Inequality,
new Cast (new TypeExpression (Module.Compiler.BuiltinTypes.Object, Location), new LocalVariableReference (obj1, Location), Location),
new Cast (new TypeExpression (Module.Compiler.BuiltinTypes.Object, Location), new LocalVariableReference (obj2, Location), Location)));
var body = new ExplicitBlock (block, Location, Location);
block.AddStatement (new Do (body, cond, Location, Location));
body.AddStatement (new StatementExpression (
new SimpleAssign (new LocalVariableReference (obj2, Location), new LocalVariableReference (obj1, Location))));
var args_oper = new Arguments (2);
args_oper.Add (new Argument (new LocalVariableReference (obj2, Location)));
args_oper.Add (new Argument (block.GetParameterReference (0, Location)));
var op_method = GetOperation (Location);
var args = new Arguments (3);
args.Add (new Argument (f_expr, Argument.AType.Ref));
args.Add (new Argument (new Cast (
new TypeExpression (field_info.MemberType, Location),
new Invocation (MethodGroupExpr.CreatePredefined (op_method, op_method.DeclaringType, Location), args_oper),
Location)));
args.Add (new Argument (new LocalVariableReference (obj1, Location)));
var cas = Module.PredefinedMembers.InterlockedCompareExchange_T.Resolve (Location);
if (cas == null)
return;
body.AddStatement (new StatementExpression (new SimpleAssign (
new LocalVariableReference (obj1, Location),
new Invocation (MethodGroupExpr.CreatePredefined (cas, cas.DeclaringType, Location), args))));
}
protected override Expression DoResolve (ResolveContext rc)
{
var args = new Arguments(1);
args.Add (new Argument(new StringLiteral(rc.BuiltinTypes, Xml, this.Location)));
return new New(new TypeExpression(rc.Module.PredefinedTypes.AsXml.Resolve(), this.Location),
args, this.Location).Resolve (rc);
}
protected override Expression DoResolve (ResolveContext ec)
{
Expression clone = source.Clone (new CloneContext ());
clone = clone.Resolve (ec);
if (clone == null)
return null;
//
// A useful feature for the REPL: if we can resolve the expression
// as a type, Describe the type;
//
if (ec.Module.Evaluator.DescribeTypeExpressions){
var old_printer = ec.Report.SetPrinter (new SessionReportPrinter ());
Expression tclone;
try {
// Note: clone context cannot be shared otherwise block mapping would leak
tclone = source.Clone (new CloneContext ());
tclone = tclone.Resolve (ec, ResolveFlags.Type);
if (ec.Report.Errors > 0)
tclone = null;
} finally {
ec.Report.SetPrinter (old_printer);
}
if (tclone is TypeExpr) {
Arguments args = new Arguments (1);
args.Add (new Argument (new TypeOf ((TypeExpr) clone, Location)));
return new Invocation (new SimpleName ("Describe", Location), args).Resolve (ec);
}
}
// This means its really a statement.
if (clone.Type.Kind == MemberKind.Void || clone is DynamicInvocation || clone is Assign) {
return clone;
}
source = clone;
return base.DoResolve (ec);
}
public ArrayInitializer CreateDynamicBinderArguments (ResolveContext rc)
{
Location loc = Location.Null;
var all = new ArrayInitializer (args.Count, loc);
MemberAccess binder = DynamicExpressionStatement.GetBinderNamespace (loc);
foreach (Argument a in args) {
Arguments dargs = new Arguments (2);
// CSharpArgumentInfoFlags.None = 0
const string info_flags_enum = "CSharpArgumentInfoFlags";
Expression info_flags = new IntLiteral (rc.BuiltinTypes, 0, loc);
if (a.Expr is Constant) {
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "Constant", loc));
} else if (a.ArgType == Argument.AType.Ref) {
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsRef", loc));
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
} else if (a.ArgType == Argument.AType.Out) {
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsOut", loc));
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
} else if (a.ArgType == Argument.AType.DynamicTypeName) {
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsStaticType", loc));
}
var arg_type = a.Expr.Type;
if (arg_type.BuiltinType != BuiltinTypeSpec.Type.Dynamic && arg_type != InternalType.NullLiteral) {
MethodGroupExpr mg = a.Expr as MethodGroupExpr;
if (mg != null) {
rc.Report.Error (1976, a.Expr.Location,
"The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method",
mg.Name);
} else if (arg_type == InternalType.AnonymousMethod) {
rc.Report.Error (1977, a.Expr.Location,
"An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast");
} else if (arg_type.Kind == MemberKind.Void || arg_type == InternalType.Arglist || arg_type.IsPointer) {
rc.Report.Error (1978, a.Expr.Location,
"An expression of type `{0}' cannot be used as an argument of dynamic operation",
TypeManager.CSharpName (arg_type));
}
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
string named_value;
NamedArgument na = a as NamedArgument;
if (na != null) {
info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "NamedArgument", loc));
named_value = na.Name;
} else {
named_value = null;
}
dargs.Add (new Argument (info_flags));
dargs.Add (new Argument (new StringLiteral (rc.BuiltinTypes, named_value, loc)));
all.Add (new Invocation (new MemberAccess (new MemberAccess (binder, "CSharpArgumentInfo", loc), "Create", loc), dargs));
}
return all;
}
public ArrayInitializer CreateDynamicBinderArguments(ResolveContext rc)
{
Location loc = Location.Null;
var all = new ArrayInitializer(args.Count, loc);
MemberAccess binder = DynamicExpressionStatement.GetBinderNamespace(loc);
foreach (Argument a in args)
{
Arguments dargs = new Arguments(2);
// CSharpArgumentInfoFlags.None = 0
const string info_flags_enum = "CSharpArgumentInfoFlags";
Expression info_flags = new IntLiteral(rc.BuiltinTypes, 0, loc);
if (a.Expr is Constant)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "Constant", loc));
}
else if (a.ArgType == Argument.AType.Ref)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsRef", loc));
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
else if (a.ArgType == Argument.AType.Out)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsOut", loc));
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
else if (a.ArgType == Argument.AType.DynamicTypeName)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsStaticType", loc));
}
var arg_type = a.Expr.Type;
if (arg_type.BuiltinType != BuiltinTypeSpec.Type.Dynamic && arg_type != InternalType.NullLiteral)
{
MethodGroupExpr mg = a.Expr as MethodGroupExpr;
if (mg != null)
{
rc.Report.Error(1976, a.Expr.Location,
"The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method",
mg.Name);
}
else if (arg_type == InternalType.AnonymousMethod)
{
rc.Report.Error(1977, a.Expr.Location,
"An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast");
}
else if (arg_type.Kind == MemberKind.Void || arg_type == InternalType.Arglist || arg_type.IsPointer)
{
rc.Report.Error(1978, a.Expr.Location,
"An expression of type `{0}' cannot be used as an argument of dynamic operation",
TypeManager.CSharpName(arg_type));
}
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
string named_value;
NamedArgument na = a as NamedArgument;
if (na != null)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "NamedArgument", loc));
named_value = na.Name;
}
else
{
named_value = null;
}
dargs.Add(new Argument(info_flags));
dargs.Add(new Argument(new StringLiteral(rc.BuiltinTypes, named_value, loc)));
all.Add(new Invocation(new MemberAccess(new MemberAccess(binder, "CSharpArgumentInfo", loc), "Create", loc), dargs));
}
return(all);
}
public Arguments Clone (CloneContext ctx)
{
Arguments cloned = new Arguments (args.Count);
foreach (Argument a in args)
cloned.Add (a.Clone (ctx));
return cloned;
}
static Expression ImplicitConversionStandard (ResolveContext ec, Expression expr, TypeSpec target_type, Location loc, bool explicit_cast)
{
if (expr.eclass == ExprClass.MethodGroup){
if (!target_type.IsDelegate){
return null;
}
//
// Only allow anonymous method conversions on post ISO_1
//
if (ec.Module.Compiler.Settings.Version != LanguageVersion.ISO_1){
MethodGroupExpr mg = expr as MethodGroupExpr;
if (mg != null)
return ImplicitDelegateCreation.Create (
ec, mg, target_type, loc);
}
}
TypeSpec expr_type = expr.Type;
Expression e;
if (expr_type == target_type) {
if (expr_type != InternalType.NullLiteral && expr_type != InternalType.AnonymousMethod)
return expr;
return null;
}
if (expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
switch (target_type.Kind) {
case MemberKind.ArrayType:
case MemberKind.Class:
if (target_type.BuiltinType == BuiltinTypeSpec.Type.Object)
return EmptyCast.Create (expr, target_type);
goto case MemberKind.Struct;
case MemberKind.Struct:
case MemberKind.Delegate:
case MemberKind.Enum:
case MemberKind.Interface:
case MemberKind.TypeParameter:
Arguments args = new Arguments (1);
args.Add (new Argument (expr));
return new DynamicConversion (target_type, explicit_cast ? CSharpBinderFlags.ConvertExplicit : 0, args, loc).Resolve (ec);
}
return null;
}
if (target_type.IsNullableType)
return ImplicitNulableConversion (ec, expr, target_type);
//
// Attempt to do the implicit constant expression conversions
//
Constant c = expr as Constant;
if (c != null) {
try {
c = c.ConvertImplicitly (target_type);
} catch {
throw new InternalErrorException ("Conversion error", loc);
}
if (c != null)
return c;
}
e = ImplicitNumericConversion (expr, expr_type, target_type);
if (e != null)
return e;
e = ImplicitReferenceConversion (expr, target_type, explicit_cast);
if (e != null)
return e;
e = ImplicitBoxingConversion (expr, expr_type, target_type);
if (e != null)
return e;
if (expr is IntegralConstant && target_type.IsEnum){
var i = (IntegralConstant) expr;
//
// LAMESPEC: csc allows any constant like 0 values to be converted, including const float f = 0.0
//
// An implicit enumeration conversion permits the decimal-integer-literal 0
// to be converted to any enum-type and to any nullable-type whose underlying
// type is an enum-type
//
if (i.IsZeroInteger) {
// Recreate 0 literal to remove any collected conversions
return new EnumConstant (new IntLiteral (ec.BuiltinTypes, 0, i.Location), target_type);
}
}
if (ec.IsUnsafe) {
var target_pc = target_type as PointerContainer;
if (target_pc != null) {
if (expr_type.IsPointer) {
//
// Pointer types are same when they have same element types
//
if (expr_type == target_pc)
return expr;
if (target_pc.Element.Kind == MemberKind.Void)
return EmptyCast.Create (expr, target_type);
//return null;
}
if (expr_type == InternalType.NullLiteral)
return new NullPointer (target_type, loc);
}
}
if (expr_type == InternalType.AnonymousMethod){
AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
Expression am = ame.Compatible (ec, target_type);
if (am != null)
return am.Resolve (ec);
}
if (expr_type == InternalType.Arglist && target_type == ec.Module.PredefinedTypes.ArgIterator.TypeSpec)
return expr;
//
// dynamic erasure conversion on value types
//
if (expr_type.IsStruct && TypeSpecComparer.IsEqual (expr_type, target_type))
return expr_type == target_type ? expr : EmptyCast.Create (expr, target_type);
return null;
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
type = ec.BuiltinTypes.Bool;
Arguments binder_args = new Arguments (3);
binder_args.Add (new Argument (new BinderFlags (0, this)));
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
return new Invocation (GetBinder ("IsEvent", loc), binder_args);
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
Arguments args = new Arguments (1);
args.Add (new Argument (this));
return CreateExpressionFactoryCall (ec, "Constant", args);
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (3);
binder_args.Add (new Argument (new BinderFlags (0, this)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
return new Invocation (GetBinder ("InvokeConstructor", loc), binder_args);
}
protected override Expression DoResolve (ResolveContext ec)
{
right = right.Resolve (ec);
if (right == null)
return null;
MemberAccess ma = target as MemberAccess;
using (ec.Set (ResolveContext.Options.CompoundAssignmentScope)) {
target = target.Resolve (ec);
}
if (target == null)
return null;
if (target is MethodGroupExpr){
ec.Report.Error (1656, loc,
"Cannot assign to `{0}' because it is a `{1}'",
((MethodGroupExpr)target).Name, target.ExprClassName);
return null;
}
var event_expr = target as EventExpr;
if (event_expr != null) {
source = Convert.ImplicitConversionRequired (ec, right, target.Type, loc);
if (source == null)
return null;
Expression rside;
if (op == Binary.Operator.Addition)
rside = EmptyExpression.EventAddition;
else if (op == Binary.Operator.Subtraction)
rside = EmptyExpression.EventSubtraction;
else
rside = null;
target = target.ResolveLValue (ec, rside);
if (target == null)
return null;
eclass = ExprClass.Value;
type = event_expr.Operator.ReturnType;
return this;
}
//
// Only now we can decouple the original source/target
// into a tree, to guarantee that we do not have side
// effects.
//
if (left == null)
left = new TargetExpression (target);
source = new Binary (op, left, right, true);
if (target is DynamicMemberAssignable) {
Arguments targs = ((DynamicMemberAssignable) target).Arguments;
source = source.Resolve (ec);
Arguments args = new Arguments (targs.Count + 1);
args.AddRange (targs);
args.Add (new Argument (source));
var binder_flags = CSharpBinderFlags.ValueFromCompoundAssignment;
//
// Compound assignment does target conversion using additional method
// call, set checked context as the binary operation can overflow
//
if (ec.HasSet (ResolveContext.Options.CheckedScope))
binder_flags |= CSharpBinderFlags.CheckedContext;
if (target is DynamicMemberBinder) {
source = new DynamicMemberBinder (ma.Name, binder_flags, args, loc).Resolve (ec);
// Handles possible event addition/subtraction
if (op == Binary.Operator.Addition || op == Binary.Operator.Subtraction) {
args = new Arguments (targs.Count + 1);
args.AddRange (targs);
args.Add (new Argument (right));
string method_prefix = op == Binary.Operator.Addition ?
Event.AEventAccessor.AddPrefix : Event.AEventAccessor.RemovePrefix;
var invoke = DynamicInvocation.CreateSpecialNameInvoke (
new MemberAccess (right, method_prefix + ma.Name, loc), args, loc).Resolve (ec);
args = new Arguments (targs.Count);
args.AddRange (targs);
source = new DynamicEventCompoundAssign (ma.Name, args,
(ExpressionStatement) source, (ExpressionStatement) invoke, loc).Resolve (ec);
}
} else {
source = new DynamicIndexBinder (binder_flags, args, loc).Resolve (ec);
}
return source;
}
return base.DoResolve (ec);
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (member != null ? 5 : 3);
bool is_member_access = member is MemberAccess;
CSharpBinderFlags call_flags;
if (!is_member_access && member is SimpleName) {
call_flags = CSharpBinderFlags.InvokeSimpleName;
is_member_access = true;
} else {
call_flags = 0;
}
binder_args.Add (new Argument (new BinderFlags (call_flags, this)));
if (is_member_access)
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, member.Name, member.Location)));
if (member != null && member.HasTypeArguments) {
TypeArguments ta = member.TypeArguments;
if (ta.Resolve (ec)) {
var targs = new ArrayInitializer (ta.Count, loc);
foreach (TypeSpec t in ta.Arguments)
targs.Add (new TypeOf (t, loc));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (targs, loc)));
}
} else if (is_member_access) {
binder_args.Add (new Argument (new NullLiteral (loc)));
}
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
Expression real_args;
if (args == null) {
// Cannot be null because .NET trips over
real_args = new ArrayCreation (
new MemberAccess (GetBinderNamespace (loc), "CSharpArgumentInfo", loc),
new ArrayInitializer (0, loc), loc);
} else {
real_args = new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc);
}
binder_args.Add (new Argument (real_args));
return new Invocation (GetBinder (is_member_access ? "InvokeMember" : "Invoke", loc), binder_args);
}
protected override Expression ResolveConversions (ResolveContext ec)
{
//
// LAMESPEC: Under dynamic context no target conversion is happening
// This allows more natual dynamic behaviour but breaks compatibility
// with static binding
//
if (target is RuntimeValueExpression)
return this;
TypeSpec target_type = target.Type;
//
// 1. the return type is implicitly convertible to the type of target
//
if (Convert.ImplicitConversionExists (ec, source, target_type)) {
source = Convert.ImplicitConversion (ec, source, target_type, loc);
return this;
}
//
// Otherwise, if the selected operator is a predefined operator
//
Binary b = source as Binary;
if (b == null && source is ReducedExpression)
b = ((ReducedExpression) source).OriginalExpression as Binary;
if (b != null) {
//
// 2a. the operator is a shift operator
//
// 2b. the return type is explicitly convertible to the type of x, and
// y is implicitly convertible to the type of x
//
if ((b.Oper & Binary.Operator.ShiftMask) != 0 ||
Convert.ImplicitConversionExists (ec, right, target_type)) {
source = Convert.ExplicitConversion (ec, source, target_type, loc);
return this;
}
}
if (source.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
Arguments arg = new Arguments (1);
arg.Add (new Argument (source));
return new SimpleAssign (target, new DynamicConversion (target_type, CSharpBinderFlags.ConvertExplicit, arg, loc), loc).Resolve (ec);
}
right.Error_ValueCannotBeConverted (ec, target_type, false);
return null;
}
protected virtual Arguments CreateSetterArguments (ResolveContext rc, Expression rhs)
{
var setter_args = new Arguments (Arguments.Count + 1);
setter_args.AddRange (Arguments);
setter_args.Add (new Argument (rhs));
return setter_args;
}
protected override Expression DoResolve (ResolveContext ec)
{
// if (ec.Target == Target.JavaScript) {
// type = ec.BuiltinTypes.Dynamic;
// eclass = ExprClass.Value;
// return this;
// }
if (Expr is ElementAccess) {
var elem_access = Expr as ElementAccess;
if (elem_access.Arguments.Count != 1) {
ec.Report.Error (7021, loc, "delete statement must have only one index argument.");
return null;
}
var expr = elem_access.Expr.Resolve (ec);
if (expr.Type == null) {
return null;
}
if (expr.Type.IsArray) {
ec.Report.Error (7021, loc, "delete statement not allowed on arrays.");
return null;
}
if (ec.Target == Target.JavaScript) {
Expr = Expr.Resolve(ec);
return this;
}
removeExpr = new Invocation (new MemberAccess (expr, "Remove", loc), elem_access.Arguments);
return removeExpr.Resolve (ec);
} else if (Expr is MemberAccess) {
if (ec.Target == Target.JavaScript) {
Expr = Expr.Resolve(ec);
return this;
}
var memb_access = Expr as MemberAccess;
var expr = memb_access.LeftExpression.Resolve (ec);
if (expr.Type == null) {
return null;
}
var args = new Arguments(1);
args.Add (new Argument(new StringLiteral(ec.BuiltinTypes, memb_access.Name, loc)));
removeExpr = new Invocation (new MemberAccess (expr, "Remove", loc), args);
return removeExpr.Resolve (ec);
} else {
// Error is reported elsewhere.
return null;
}
}
public ExpressionStatement CreateExpressionTreeVariable (BlockContext ec)
{
if ((modFlags & Modifier.RefOutMask) != 0)
ec.Report.Error (1951, Location, "An expression tree parameter cannot use `ref' or `out' modifier");
expr_tree_variable = TemporaryVariableReference.Create (ResolveParameterExpressionType (ec, Location).Type, ec.CurrentBlock.ParametersBlock, Location);
expr_tree_variable = (TemporaryVariableReference) expr_tree_variable.Resolve (ec);
Arguments arguments = new Arguments (2);
arguments.Add (new Argument (new TypeOf (parameter_type, Location)));
arguments.Add (new Argument (new StringConstant (ec.BuiltinTypes, Name, Location)));
return new SimpleAssign (ExpressionTreeVariableReference (),
Expression.CreateExpressionFactoryCall (ec, "Parameter", null, arguments, Location));
}
protected override Expression DoResolve(ResolveContext ec)
{
right = right.Resolve(ec);
if (right == null)
{
return(null);
}
MemberAccess ma = target as MemberAccess;
using (ec.Set(ResolveContext.Options.CompoundAssignmentScope)) {
target = target.Resolve(ec);
}
if (target == null)
{
return(null);
}
if (target is MethodGroupExpr)
{
ec.Report.Error(1656, loc,
"Cannot assign to `{0}' because it is a `{1}'",
((MethodGroupExpr)target).Name, target.ExprClassName);
return(null);
}
var event_expr = target as EventExpr;
if (event_expr != null)
{
source = Convert.ImplicitConversionRequired(ec, right, target.Type, loc);
if (source == null)
{
return(null);
}
Expression rside;
if (op == Binary.Operator.Addition)
{
rside = EmptyExpression.EventAddition;
}
else if (op == Binary.Operator.Subtraction)
{
rside = EmptyExpression.EventSubtraction;
}
else
{
rside = null;
}
target = target.ResolveLValue(ec, rside);
if (target == null)
{
return(null);
}
eclass = ExprClass.Value;
type = event_expr.Operator.ReturnType;
return(this);
}
//
// Only now we can decouple the original source/target
// into a tree, to guarantee that we do not have side
// effects.
//
if (left == null)
{
left = new TargetExpression(target);
}
source = new Binary(op, left, right, true);
if (target is DynamicMemberAssignable)
{
Arguments targs = ((DynamicMemberAssignable)target).Arguments;
source = source.Resolve(ec);
Arguments args = new Arguments(targs.Count + 1);
args.AddRange(targs);
args.Add(new Argument(source));
var binder_flags = CSharpBinderFlags.ValueFromCompoundAssignment;
//
// Compound assignment does target conversion using additional method
// call, set checked context as the binary operation can overflow
//
if (ec.HasSet(ResolveContext.Options.CheckedScope))
{
binder_flags |= CSharpBinderFlags.CheckedContext;
}
if (target is DynamicMemberBinder)
{
source = new DynamicMemberBinder(ma.Name, binder_flags, args, loc).Resolve(ec);
// Handles possible event addition/subtraction
if (op == Binary.Operator.Addition || op == Binary.Operator.Subtraction)
{
args = new Arguments(targs.Count + 1);
args.AddRange(targs);
args.Add(new Argument(right));
string method_prefix = op == Binary.Operator.Addition ?
Event.AEventAccessor.AddPrefix : Event.AEventAccessor.RemovePrefix;
var invoke = DynamicInvocation.CreateSpecialNameInvoke(
new MemberAccess(right, method_prefix + ma.Name, loc), args, loc).Resolve(ec);
args = new Arguments(targs.Count);
args.AddRange(targs);
source = new DynamicEventCompoundAssign(ma.Name, args,
(ExpressionStatement)source, (ExpressionStatement)invoke, loc).Resolve(ec);
}
}
else
{
source = new DynamicIndexBinder(binder_flags, args, loc).Resolve(ec);
}
return(source);
}
return(base.DoResolve(ec));
}