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

public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one, out MethodSpec ambiguousCandidate, ref bool optional)

354

{

355

InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll, out ambiguousCandidate, ref optional);

356

}

357

358

/// <remarks>

359

/// If a method in Type `t' (or null to look in all interfaces

360

/// and the base abstract class) with name `Name', return type `ret_type' and

361

/// arguments `args' implements an interface, this method will

362

/// return the MethodInfo that this method implements.

363

///

364

/// If `name' is null, we operate solely on the method's signature. This is for

365

/// instance used when implementing indexers.

366

///

367

/// The `Operation op' controls whether to lookup, clear the pending bit, or clear

368

/// all the methods with the given signature.

369

///

370

/// The `MethodInfo need_proxy' is used when we're implementing an interface's

371

/// indexer in a class. If the new indexer's IndexerName does not match the one

372

/// that was used in the interface, then we always need to create a proxy for it.

373

///

374

/// </remarks>

375

public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op, out MethodSpec ambiguousCandidate, ref bool optional)

376

{

377

ambiguousCandidate = null;

378

379

if (pending_implementations == null)

380

return null;

381

382

TypeSpec ret_type = method.method.ReturnType;

383

ParametersCompiled args = method.method.ParameterInfo;

384

bool is_indexer = method.method is Indexer.SetIndexerMethod || method.method is Indexer.GetIndexerMethod;

385

MethodSpec m;

386

387

foreach (TypeAndMethods tm in pending_implementations){

388

if (!(iType == null || tm.type == iType))

389

continue;

390

391

int method_count = tm.methods.Count;

392

for (int i = 0; i < method_count; i++){

393

m = tm.methods [i];

394

395

if (m == null)

396

continue;

397

398

if (is_indexer) {

399

if (!m.IsAccessor || m.Parameters.IsEmpty)

400

continue;

401

} else {

402

if (name.Name != m.Name)

403

continue;

404

405

if (m.Arity != name.Arity)

406

continue;

407

}

408

409

if (!TypeSpecComparer.Override.IsEqual (m.Parameters, args))

410

continue;

411

412

if (!TypeSpecComparer.Override.IsEqual (m.ReturnType, ret_type)) {

413

tm.found[i] = method;

414

continue;

415

}

416

417

418

// `need_proxy' is not null when we're implementing an

419

// interface indexer and this is Clear(One/All) operation.

420

421

// If `name' is null, then we do a match solely based on the

422

// signature and not on the name (this is done in the Lookup

423

// for an interface indexer).

424

425

if (op != Operation.Lookup) {

426

if (m.IsAccessor != method.method.IsAccessor)

427

continue;

428

429

// If `t != null', then this is an explicitly interface

430

// implementation and we can always clear the method.

431

// `need_proxy' is not null if we're implementing an

432

// interface indexer. In this case, we need to create

433

// a proxy if the implementation's IndexerName doesn't

434

// match the IndexerName in the interface.

435

if (m.DeclaringType.IsInterface && iType == null && name.Name != m.Name) { // TODO: This is very expensive comparison

436

tm.need_proxy[i] = method.method.Spec;

437

} else {

438

tm.methods[i] = null;

439

}

440

} else {

441

tm.found [i] = method;

442

optional = tm.optional;

443

}

444

445

if (op == Operation.Lookup && name.ExplicitInterface != null && ambiguousCandidate == null) {

446

ambiguousCandidate = m;

447

continue;

448

}

449

450

451

// Lookups and ClearOne return

452

453

if (op != Operation.ClearAll)

454

return m;

455

}

456

457

// If a specific type was requested, we can stop now.

458

if (tm.type == iType)

459

break;

460

}

461

462

m = ambiguousCandidate;

463

ambiguousCandidate = null;

464

return m;

465

}

466

467

/// <summary>

468

/// C# allows this kind of scenarios:

469

/// interface I { void M (); }

470

/// class X { public void M (); }

471

/// class Y : X, I { }

472

///

473

/// For that case, we create an explicit implementation function

474

/// I.M in Y.

475

/// </summary>

476

void DefineProxy (TypeSpec iface, MethodSpec base_method, MethodSpec iface_method)

477

{

478

// TODO: Handle nested iface names

479

string proxy_name;

480

var ns = iface.MemberDefinition.Namespace;

481

if (string.IsNullOrEmpty (ns))

482

proxy_name = iface.MemberDefinition.Name + "." + iface_method.Name;

483

else

484

proxy_name = ns + "." + iface.MemberDefinition.Name + "." + iface_method.Name;

485

486

var param = iface_method.Parameters;

487

488

MethodBuilder proxy = container.TypeBuilder.DefineMethod (

489

proxy_name,

490

MethodAttributes.Private |

491

MethodAttributes.HideBySig |

492

MethodAttributes.NewSlot |

493

MethodAttributes.CheckAccessOnOverride |

494

MethodAttributes.Virtual | MethodAttributes.Final,

495

CallingConventions.Standard | CallingConventions.HasThis,

496

base_method.ReturnType.GetMetaInfo (), param.GetMetaInfo ());

497

498

if (iface_method.IsGeneric) {

499

var gnames = iface_method.GenericDefinition.TypeParameters.Select (l => l.Name).ToArray ();

500

proxy.DefineGenericParameters (gnames);

501

}

502

503

for (int i = 0; i < param.Count; i++) {

504

string name = param.FixedParameters [i].Name;

505

ParameterAttributes attr = ParametersCompiled.GetParameterAttribute (param.FixedParameters [i].ModFlags);

506

proxy.DefineParameter (i + 1, attr, name);

507

}

508

509

int top = param.Count;

510

var ec = new EmitContext (new ProxyMethodContext (container), proxy.GetILGenerator (), null, null);

511

ec.EmitThis ();

512

// TODO: GetAllParametersArguments

513

for (int i = 0; i < top; i++)

514

ec.EmitArgumentLoad (i);

515

516

ec.Emit (OpCodes.Call, base_method);

517

ec.Emit (OpCodes.Ret);

518

519

container.TypeBuilder.DefineMethodOverride (proxy, (MethodInfo) iface_method.GetMetaInfo ());

520

}

521

522

/// <summary>

523

/// This function tells whether one of our base classes implements

524

/// the given method (which turns out, it is valid to have an interface

525

/// implementation in a base

526

/// </summary>

527

bool BaseImplements (TypeSpec iface_type, MethodSpec mi, out MethodSpec base_method)

528

{

529

base_method = null;

530

var base_type = container.BaseType;

531

532

533

// Setup filter with no return type to give better error message

534

// about mismatch at return type when the check bellow rejects them

535

536

var parameters = mi.Parameters;

537

while (true) {

538

var candidates = MemberCache.FindMembers (base_type, mi.Name, false);

539

if (candidates == null)

540

return false;

541

542

MethodSpec similar_candidate = null;

543

foreach (var candidate in candidates) {

544

if (candidate.Kind != MemberKind.Method)

545

continue;

546

547

if (candidate.Arity != mi.Arity)

548

continue;

549

550

var candidate_param = ((MethodSpec) candidate).Parameters;

551

if (!TypeSpecComparer.Override.IsSame (parameters.Types, candidate_param.Types))

552

continue;

553

554

bool modifiers_match = true;

555

for (int i = 0; i < parameters.Count; ++i) {

556

557

// First check exact ref/out match

558

559

if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) == (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask))

560

continue;

561

562

modifiers_match = false;

563

564

565

// Different in ref/out only

566

567

if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) {

568

if (similar_candidate == null) {

569

if (!candidate.IsPublic)

570

break;

571

572

if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, ((MethodSpec) candidate).ReturnType))

573

break;

574

575

// It's used for ref/out ambiguity overload check

576

similar_candidate = (MethodSpec) candidate;

577

}

578

579

continue;

580

}

581

582

similar_candidate = null;

583

break;

584

}

585

586

if (!modifiers_match)

587

continue;

588

589

590

// From this point on the candidate is used for detailed error reporting

591

// because it's very close match to what we are looking for

592

593

base_method = (MethodSpec) candidate;

594

595

if (!candidate.IsPublic)

596

return false;

597

598

if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, base_method.ReturnType))

599

return false;

600

601

if (mi.IsGeneric && !Method.CheckImplementingMethodConstraints (container, base_method, mi)) {

602

return true;

603

}

604

}

605

606

if (base_method != null) {

607

if (similar_candidate != null) {

608

Report.SymbolRelatedToPreviousError (similar_candidate);

609

Report.SymbolRelatedToPreviousError (mi);

610

Report.SymbolRelatedToPreviousError (container);

611

Report.Warning (1956, 1, ((MemberCore) base_method.MemberDefinition).Location,

612

"The interface method `{0}' implementation is ambiguous between following methods: `{1}' and `{2}' in type `{3}'",

613

mi.GetSignatureForError (), base_method.GetSignatureForError (), similar_candidate.GetSignatureForError (), container.GetSignatureForError ());

614

}

615

616

break;

617

}

618

619

base_type = candidates[0].DeclaringType.BaseType;

620

if (base_type == null)

621

return false;

622

}

623

624

if (!base_method.IsVirtual) {

625

#if STATIC

626

var base_builder = base_method.GetMetaInfo () as MethodBuilder;

627

if (base_builder != null) {

628

629

// We can avoid creating a proxy if base_method can be marked 'final virtual'. This can

630

// be done for all methods from compiled assembly

631

632

base_builder.__SetAttributes (base_builder.Attributes | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot);

633

return true;

634

}

635

#endif

636

DefineProxy (iface_type, base_method, mi);

637

}

638

639

return true;

640

}

641

642

/// <summary>

643

/// Verifies that any pending abstract methods or interface methods

644

/// were implemented.

645

/// </summary>

646

public bool VerifyPendingMethods ()

647

{

648

int top = pending_implementations.Length;

649

bool errors = false;

650

int i;

651

652

for (i = 0; i < top; i++){

653

TypeSpec type = pending_implementations [i].type;

654

655

bool base_implements_type = type.IsInterface &&

656

container.BaseType != null &&

657

container.BaseType.ImplementsInterface (type, false);

658

659

for (int j = 0; j < pending_implementations [i].methods.Count; ++j) {

660

var mi = pending_implementations[i].methods[j];

661

if (mi == null)

662

continue;

663

664

if (type.IsInterface){

665

var need_proxy =

666

pending_implementations [i].need_proxy [j];

667

668

if (need_proxy != null) {

669

DefineProxy (type, need_proxy, mi);

670

continue;

671

}

672

673

if (pending_implementations [i].optional)

674

continue;

675

676

MethodSpec candidate = null;

677

if (base_implements_type || BaseImplements (type, mi, out candidate))

678

continue;

679

680

if (candidate == null) {

681

MethodData md = pending_implementations [i].found [j];

682

if (md != null)

683

candidate = md.method.Spec;

684

}

685

686

Report.SymbolRelatedToPreviousError (mi);

687

if (candidate != null) {

688

Report.SymbolRelatedToPreviousError (candidate);

689

if (candidate.IsStatic) {

690

Report.Error (736, container.Location,

691

"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is static",

692

container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ());

693

} else if ((candidate.Modifiers & Modifiers.PUBLIC) == 0) {

694

Report.Error (737, container.Location,

695

"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' in not public",

696

container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ());

697

} else {

698

Report.Error (738, container.Location,

699

"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' return type `{3}' does not match interface member return type `{4}'",

700

container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError (),

701

candidate.ReturnType.GetSignatureForError (), mi.ReturnType.GetSignatureForError ());

702

}

703

} else {

704

Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'",

705

container.GetSignatureForError (), mi.GetSignatureForError ());

706

}

707

} else {

708

Report.SymbolRelatedToPreviousError (mi);

709

Report.Error (534, container.Location, "`{0}' does not implement inherited abstract member `{1}'",

710

container.GetSignatureForError (), mi.GetSignatureForError ());

711

}

712

errors = true;

713

}

714

}

715

return errors;

716

}

717

}

718

}

Older »