~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

return mg.OverloadResolve (ec, ref arguments, null, OverloadResolver.Restrictions.CovariantDelegate | OverloadResolver.Restrictions.ProbingOnly) != null;

604

}

605

606

#region IErrorHandler Members

607

608

bool OverloadResolver.IErrorHandler.AmbiguousCandidates (ResolveContext ec, MemberSpec best, MemberSpec ambiguous)

609

{

610

return false;

611

}

612

613

bool OverloadResolver.IErrorHandler.ArgumentMismatch (ResolveContext rc, MemberSpec best, Argument arg, int index)

614

{

615

Error_ConversionFailed (rc, best as MethodSpec, null);

616

return true;

617

}

618

619

bool OverloadResolver.IErrorHandler.NoArgumentMatch (ResolveContext rc, MemberSpec best)

620

{

621

Error_ConversionFailed (rc, best as MethodSpec, null);

622

return true;

623

}

624

625

bool OverloadResolver.IErrorHandler.TypeInferenceFailed (ResolveContext rc, MemberSpec best)

626

{

627

return false;

628

}

629

630

#endregion

631

}

632

633

634

// Created from the conversion code

635

636

public class ImplicitDelegateCreation : DelegateCreation

637

{

638

ImplicitDelegateCreation (TypeSpec t, MethodGroupExpr mg, Location l)

639

{

640

type = t;

641

this.method_group = mg;

642

loc = l;

643

}

644

645

static public Expression Create (ResolveContext ec, MethodGroupExpr mge,

646

TypeSpec target_type, Location loc)

647

{

648

ImplicitDelegateCreation d = new ImplicitDelegateCreation (target_type, mge, loc);

649

return d.DoResolve (ec);

650

}

651

}

652

653

654

// A delegate-creation-expression, invoked from the `New' class

655

656

public class NewDelegate : DelegateCreation

657

{

658

public Arguments Arguments;

659

660

661

// This constructor is invoked from the `New' expression

662

663

public NewDelegate (TypeSpec type, Arguments Arguments, Location loc)

664

{

665

this.type = type;

666

this.Arguments = Arguments;

667

this.loc = loc;

668

}

669

670

protected override Expression DoResolve (ResolveContext ec)

671

{

672

if (Arguments == null || Arguments.Count != 1) {

673

ec.Report.Error (149, loc, "Method name expected");

674

return null;

675

}

676

677

Argument a = Arguments [0];

678

if (!a.ResolveMethodGroup (ec))

679

return null;

680

681

Expression e = a.Expr;

682

683

AnonymousMethodExpression ame = e as AnonymousMethodExpression;

684

if (ame != null && ec.Module.Compiler.Settings.Version != LanguageVersion.ISO_1) {

685

e = ame.Compatible (ec, type);

686

if (e == null)

687

return null;

688

689

return e.Resolve (ec);

690

}

691

692

method_group = e as MethodGroupExpr;

693

if (method_group == null) {

694

if (e.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {

695

e = Convert.ImplicitConversionRequired (ec, e, type, loc);

696

} else if (!e.Type.IsDelegate) {

697

e.Error_UnexpectedKind (ec, ResolveFlags.MethodGroup | ResolveFlags.Type, loc);

698

return null;

699

}

700

701

702

// An argument is not a method but another delegate

703

704

method_group = new MethodGroupExpr (Delegate.GetInvokeMethod (e.Type), e.Type, loc);

705

method_group.InstanceExpression = e;

706

}

707

708

return base.DoResolve (ec);

709

}

710

}

711

712

713

// Invocation converted to delegate Invoke call

714

715

class DelegateInvocation : ExpressionStatement

716

{

717

readonly Expression InstanceExpr;

718

Arguments arguments;

719

MethodSpec method;

720

721

public DelegateInvocation (Expression instance_expr, Arguments args, Location loc)

722

{

723

this.InstanceExpr = instance_expr;

724

this.arguments = args;

725

this.loc = loc;

726

}

727

728

public override bool ContainsEmitWithAwait ()

729

{

730

return InstanceExpr.ContainsEmitWithAwait () || (arguments != null && arguments.ContainsEmitWithAwait ());

731

}

732

733

public override Expression CreateExpressionTree (ResolveContext ec)

734

{

735

Arguments args = Arguments.CreateForExpressionTree (ec, this.arguments,

736

InstanceExpr.CreateExpressionTree (ec));

737

738

return CreateExpressionFactoryCall (ec, "Invoke", args);

739

}

740

741

protected override Expression DoResolve (ResolveContext ec)

742

{

743

TypeSpec del_type = InstanceExpr.Type;

744

if (del_type == null)

745

return null;

746

747

748

// Do only core overload resolution the rest of the checks has been

749

// done on primary expression

750

751

method = Delegate.GetInvokeMethod (del_type);

752

var res = new OverloadResolver (new MemberSpec[] { method }, OverloadResolver.Restrictions.DelegateInvoke, loc);

753

var valid = res.ResolveMember<MethodSpec> (ec, ref arguments);

754

if (valid == null && !res.BestCandidateIsDynamic)

755

return null;

756

757

type = method.ReturnType;

758

eclass = ExprClass.Value;

759

return this;

760

}

761

762

public override void Emit (EmitContext ec)

763

{

764

765

// Invocation on delegates call the virtual Invoke member

766

// so we are always `instance' calls

767

768

var call = new CallEmitter ();

769

call.InstanceExpression = InstanceExpr;

770

call.EmitPredefined (ec, method, arguments);

771

}

772

773

public override void EmitStatement (EmitContext ec)

774

{

775

Emit (ec);

776

777

// Pop the return value if there is one

778

779

if (type.Kind != MemberKind.Void)

780

ec.Emit (OpCodes.Pop);

781

}

782

783

public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)

784

{

785

return Invocation.MakeExpression (ctx, InstanceExpr, method, arguments);

786

}

787

}

788

}

Older »