public BlockContext(ResolveContext rc, ExplicitBlock block, TypeSpec returnType) : this(rc.MemberContext, block, returnType) { if (rc.IsUnsafe) { flags |= ResolveContext.Options.UnsafeScope; } if (rc.HasSet(ResolveContext.Options.CheckedScope)) { flags |= ResolveContext.Options.CheckedScope; } if (rc.IsInProbingMode) { flags |= ResolveContext.Options.ProbingMode; } if (rc.HasSet(ResolveContext.Options.FieldInitializerScope)) { flags |= ResolveContext.Options.FieldInitializerScope; } if (rc.HasSet(ResolveContext.Options.ExpressionTreeConversion)) { flags |= ResolveContext.Options.ExpressionTreeConversion; } if (rc.HasSet(ResolveContext.Options.BaseInitializer)) { flags |= ResolveContext.Options.BaseInitializer; } }
protected override Expression DoResolve(ResolveContext rc) { if (rc.HasSet(ResolveContext.Options.LockScope)) { rc.Report.Error(1996, loc, "The `await' operator cannot be used in the body of a lock statement"); } if (rc.IsUnsafe) { rc.Report.Error(4004, loc, "The `await' operator cannot be used in an unsafe context"); } var bc = (BlockContext)rc; stmt = new AwaitStatement(expr, loc); if (!stmt.Resolve(bc)) { return(null); } type = stmt.ResultType; eclass = ExprClass.Variable; return(this); }
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)); }
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)); }
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)); }