~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric

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

597

}

598

599

#region IErrorHandler Members

600

601

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

602

{

603

return false;

604

}

605

606

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

607

{

608

Error_ConversionFailed (rc, best as MethodSpec, null);

609

return true;

610

}

611

612

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

613

{

614

Error_ConversionFailed (rc, best as MethodSpec, null);

615

return true;

616

}

617

618

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

619

{

620

return false;

621

}

622

623

#endregion

624

}

625

626

627

// Created from the conversion code

628

629

public class ImplicitDelegateCreation : DelegateCreation

630

{

631

ImplicitDelegateCreation (TypeSpec t, MethodGroupExpr mg, Location l)

632

{

633

type = t;

634

this.method_group = mg;

635

loc = l;

636

}

637

638

static public Expression Create (ResolveContext ec, MethodGroupExpr mge,

639

TypeSpec target_type, Location loc)

640

{

641

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

642

return d.DoResolve (ec);

643

}

644

}

645

646

647

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

648

649

public class NewDelegate : DelegateCreation

650

{

651

public Arguments Arguments;

652

653

654

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

655

656

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

657

{

658

this.type = type;

659

this.Arguments = Arguments;

660

this.loc = loc;

661

}

662

663

protected override Expression DoResolve (ResolveContext ec)

664

{

665

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

666

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

667

return null;

668

}

669

670

Argument a = Arguments [0];

671

if (!a.ResolveMethodGroup (ec))

672

return null;

673

674

Expression e = a.Expr;

675

676

AnonymousMethodExpression ame = e as AnonymousMethodExpression;

677

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

678

e = ame.Compatible (ec, type);

679

if (e == null)

680

return null;

681

682

return e.Resolve (ec);

683

}

684

685

method_group = e as MethodGroupExpr;

686

if (method_group == null) {

687

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

688

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

689

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

690

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

691

return null;

692

}

693

694

695

// An argument is not a method but another delegate

696

697

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

698

method_group.InstanceExpression = e;

699

}

700

701

return base.DoResolve (ec);

702

}

703

}

704

705

706

// Invocation converted to delegate Invoke call

707

708

class DelegateInvocation : ExpressionStatement

709

{

710

readonly Expression InstanceExpr;

711

Arguments arguments;

712

MethodSpec method;

713

714

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

715

{

716

this.InstanceExpr = instance_expr;

717

this.arguments = args;

718

this.loc = loc;

719

}

720

721

public override Expression CreateExpressionTree (ResolveContext ec)

722

{

723

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

724

InstanceExpr.CreateExpressionTree (ec));

725

726

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

727

}

728

729

protected override Expression DoResolve (ResolveContext ec)

730

{

731

TypeSpec del_type = InstanceExpr.Type;

732

if (del_type == null)

733

return null;

734

735

736

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

737

// done on primary expression

738

739

method = Delegate.GetInvokeMethod (del_type);

740

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

741

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

742

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

743

return null;

744

745

type = method.ReturnType;

746

eclass = ExprClass.Value;

747

return this;

748

}

749

750

public override void Emit (EmitContext ec)

751

{

752

753

// Invocation on delegates call the virtual Invoke member

754

// so we are always `instance' calls

755

756

Invocation.EmitCall (ec, InstanceExpr, method, arguments, loc);

757

}

758

759

public override void EmitStatement (EmitContext ec)

760

{

761

Emit (ec);

762

763

// Pop the return value if there is one

764

765

if (type.Kind != MemberKind.Void)

766

ec.Emit (OpCodes.Pop);

767

}

768

769

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

770

{

771

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

772

}

773

}

774

}

Older »