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

public MemberList(List<ITypeResolveContext> contextPerMember, List<IUnresolvedMember> unresolvedNonPartialMembers, List<PartialMethodInfo> partialMethodInfos)

152

{

153

this.NonPartialMemberCount = unresolvedNonPartialMembers.Count;

154

this.contextPerMember = contextPerMember.ToArray();

155

this.unresolvedMembers = unresolvedNonPartialMembers.ToArray();

156

if (partialMethodInfos == null) {

157

this.resolvedMembers = new IMember[unresolvedNonPartialMembers.Count];

158

} else {

159

this.resolvedMembers = new IMember[unresolvedNonPartialMembers.Count + partialMethodInfos.Count];

160

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

161

var info = partialMethodInfos[i];

162

int memberIndex = NonPartialMemberCount + i;

163

resolvedMembers[memberIndex] = DefaultResolvedMethod.CreateFromMultipleParts(

164

info.Parts.ToArray(), info.Contexts.ToArray (), false);

165

}

166

}

167

}

168

169

public IMember this[int index] {

170

get {

171

IMember output = LazyInit.VolatileRead(ref resolvedMembers[index]);

172

if (output != null) {

173

return output;

174

}

175

return LazyInit.GetOrSet(ref resolvedMembers[index], unresolvedMembers[index].CreateResolved(contextPerMember[index]));

176

}

177

set { throw new NotSupportedException(); }

178

}

179

180

public int Count {

181

get { return resolvedMembers.Length; }

182

}

183

184

bool ICollection<IMember>.IsReadOnly {

185

get { return true; }

186

}

187

188

public int IndexOf(IMember item)

189

{

190

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

191

if (this[i].Equals(item))

192

return i;

193

}

194

return -1;

195

}

196

197

void IList<IMember>.Insert(int index, IMember item)

198

{

199

throw new NotSupportedException();

200

}

201

202

void IList<IMember>.RemoveAt(int index)

203

{

204

throw new NotSupportedException();

205

}

206

207

void ICollection<IMember>.Add(IMember item)

208

{

209

throw new NotSupportedException();

210

}

211

212

void ICollection<IMember>.Clear()

213

{

214

throw new NotSupportedException();

215

}

216

217

bool ICollection<IMember>.Contains(IMember item)

218

{

219

return IndexOf(item) >= 0;

220

}

221

222

void ICollection<IMember>.CopyTo(IMember[] array, int arrayIndex)

223

{

224

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

225

array[arrayIndex + i] = this[i];

226

}

227

}

228

229

bool ICollection<IMember>.Remove(IMember item)

230

{

231

throw new NotSupportedException();

232

}

233

234

public IEnumerator<IMember> GetEnumerator()

235

{

236

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

237

yield return this[i];

238

}

239

}

240

241

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

242

{

243

return GetEnumerator();

244

}

245

}

246

247

sealed class PartialMethodInfo

248

{

249

public readonly string Name;

250

public readonly int TypeParameterCount;

251

public readonly IList<IParameter> Parameters;

252

public readonly List<IUnresolvedMethod> Parts = new List<IUnresolvedMethod>();

253

public readonly List<ITypeResolveContext> Contexts = new List<ITypeResolveContext>();

254

255

public PartialMethodInfo(IUnresolvedMethod method, ITypeResolveContext context)

256

{

257

this.Name = method.Name;

258

this.TypeParameterCount = method.TypeParameters.Count;

259

this.Parameters = method.Parameters.CreateResolvedParameters(context);

260

this.Parts.Add(method);

261

this.Contexts.Add (context);

262

}

263

264

public void AddPart(IUnresolvedMethod method, ITypeResolveContext context)

265

{

266

if (method.IsPartialMethodImplementation) {

267

// make the implementation the primary part

268

this.Parts.Insert(0, method);

269

this.Contexts.Insert (0, context);

270

} else {

271

this.Parts.Add(method);

272

this.Contexts.Add (context);

273

}

274

}

275

276

public bool IsSameSignature(PartialMethodInfo other, StringComparer nameComparer)

277

{

278

return nameComparer.Equals(this.Name, other.Name)

279

&& this.TypeParameterCount == other.TypeParameterCount

280

&& ParameterListComparer.Instance.Equals(this.Parameters, other.Parameters);

281

}

282

}

283

284

MemberList memberList;

285

286

MemberList GetMemberList()

287

{

288

var result = LazyInit.VolatileRead(ref this.memberList);

289

if (result != null) {

290

return result;

291

}

292

List<IUnresolvedMember> unresolvedMembers = new List<IUnresolvedMember>();

293

List<ITypeResolveContext> contextPerMember = new List<ITypeResolveContext>();

294

List<PartialMethodInfo> partialMethodInfos = null;

295

bool addDefaultConstructorIfRequired = false;

296

foreach (IUnresolvedTypeDefinition part in parts) {

297

ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext);

298

ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this);

299

foreach (var member in part.Members) {

300

IUnresolvedMethod method = member as IUnresolvedMethod;

301

if (method != null && (method.IsPartialMethodDeclaration || method.IsPartialMethodImplementation)) {

302

// Merge partial method declaration and implementation

303

if (partialMethodInfos == null)

304

partialMethodInfos = new List<PartialMethodInfo>();

305

PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart);

306

PartialMethodInfo existingInfo = null;

307

foreach (var info in partialMethodInfos) {

308

if (newInfo.IsSameSignature(info, Compilation.NameComparer)) {

309

existingInfo = info;

310

break;

311

}

312

}

313

if (existingInfo != null) {

314

// Add the unresolved method to the PartialMethodInfo:

315

existingInfo.AddPart(method, contextForPart);

316

} else {

317

partialMethodInfos.Add(newInfo);

318

}

319

} else {

320

unresolvedMembers.Add(member);

321

contextPerMember.Add(contextForPart);

322

}

323

}

324

325

DefaultUnresolvedTypeDefinition dutd = part as DefaultUnresolvedTypeDefinition;

326

if (dutd != null) {

327

addDefaultConstructorIfRequired |= dutd.AddDefaultConstructorIfRequired;

328

}

329

}

330

if (addDefaultConstructorIfRequired) {

331

TypeKind kind = this.Kind;

332

if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic)

333

|| kind == TypeKind.Enum || kind == TypeKind.Struct)

334

{

335

contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));

336

unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0]));

337

}

338

}

339

result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos);

340

return LazyInit.GetOrSet(ref this.memberList, result);

341

}

342

343

public IList<IMember> Members {

344

get { return GetMemberList(); }

345

}

346

347

public IEnumerable<IField> Fields {

348

get {

349

var members = GetMemberList();

350

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

351

if (members.unresolvedMembers[i].EntityType == EntityType.Field)

352

yield return (IField)members[i];

353

}

354

}

355

}

356

357

public IEnumerable<IMethod> Methods {

358

get {

359

var members = GetMemberList();

360

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

361

if (members.unresolvedMembers[i] is IUnresolvedMethod)

362

yield return (IMethod)members[i];

363

}

364

for (int i = members.unresolvedMembers.Length; i < members.Count; i++) {

365

yield return (IMethod)members[i];

366

}

367

}

368

}

369

370

public IEnumerable<IProperty> Properties {

371

get {

372

var members = GetMemberList();

373

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

374

switch (members.unresolvedMembers[i].EntityType) {

375

case EntityType.Property:

376

case EntityType.Indexer:

377

yield return (IProperty)members[i];

378

break;

379

}

380

}

381

}

382

}

383

384

public IEnumerable<IEvent> Events {

385

get {

386

var members = GetMemberList();

387

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

388

if (members.unresolvedMembers[i].EntityType == EntityType.Event)

389

yield return (IEvent)members[i];

390

}

391

}

392

}

393

#endregion

394

395

volatile KnownTypeCode knownTypeCode = (KnownTypeCode)(-1);

396

397

public KnownTypeCode KnownTypeCode {

398

get {

399

KnownTypeCode result = this.knownTypeCode;

400

if (result == (KnownTypeCode)(-1)) {

401

result = KnownTypeCode.None;

402

for (int i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++) {

403

KnownTypeReference r = KnownTypeReference.Get((KnownTypeCode)i);

404

if (r != null && r.Resolve(parentContext) == this) {

405

result = (KnownTypeCode)i;

406

break;

407

}

408

}

409

this.knownTypeCode = result;

410

}

411

return result;

412

}

413

}

414

415

volatile IType enumUnderlyingType;

416

417

public IType EnumUnderlyingType {

418

get {

419

IType result = this.enumUnderlyingType;

420

if (result == null) {

421

if (this.Kind == TypeKind.Enum) {

422

result = CalculateEnumUnderlyingType();

423

} else {

424

result = SpecialType.UnknownType;

425

}

426

this.enumUnderlyingType = result;

427

}

428

return result;

429

}

430

}

431

432

IType CalculateEnumUnderlyingType()

433

{

434

foreach (var part in parts) {

435

var context = part.CreateResolveContext(parentContext).WithCurrentTypeDefinition(this);

436

foreach (var baseTypeRef in part.BaseTypes) {

437

IType type = baseTypeRef.Resolve(context);

438

if (type.Kind != TypeKind.Unknown)

439

return type;

440

}

441

}

442

return this.Compilation.FindType(KnownTypeCode.Int32);

443

}

444

445

volatile byte hasExtensionMethods; // 0 = unknown, 1 = true, 2 = false

446

447

public bool HasExtensionMethods {

448

get {

449

byte val = this.hasExtensionMethods;

450

if (val == 0) {

451

if (CalculateHasExtensionMethods())

452

val = 1;

453

else

454

val = 2;

455

this.hasExtensionMethods = val;

456

}

457

return val == 1;

458

}

459

}

460

461

bool CalculateHasExtensionMethods()

462

{

463

bool noExtensionMethods = true;

464

foreach (var part in parts) {

465

// Return true if any part has extension methods

466

if (part.HasExtensionMethods == true)

467

return true;

468

if (part.HasExtensionMethods == null)

469

noExtensionMethods = false;

470

}

471

// Return false if all parts are known to have no extension methods

472

if (noExtensionMethods)

473

return false;

474

// If unsure, look at the resolved methods.

475

return Methods.Any(m => m.IsExtensionMethod);

476

}

477

478

public bool? IsReferenceType {

479

get {

480

switch (this.Kind) {

481

case TypeKind.Class:

482

case TypeKind.Interface:

483

case TypeKind.Module:

484

case TypeKind.Delegate:

485

return true;

486

case TypeKind.Struct:

487

case TypeKind.Enum:

488

case TypeKind.Void:

489

return false;

490

default:

491

throw new InvalidOperationException("Invalid value for TypeKind");

492

}

493

}

494

}

495

496

public int TypeParameterCount {

497

get { return parts[0].TypeParameters.Count; }

498

}

499

500

#region DirectBaseTypes

501

IList<IType> directBaseTypes;

502

503

public IEnumerable<IType> DirectBaseTypes {

504

get {

505

IList<IType> result = LazyInit.VolatileRead(ref this.directBaseTypes);

506

if (result != null) {

507

return result;

508

} else {

509

result = CalculateDirectBaseTypes();

510

return LazyInit.GetOrSet(ref this.directBaseTypes, result);

511

}

512

}

513

}

514

515

IList<IType> CalculateDirectBaseTypes()

516

{

517

List<IType> result = new List<IType>();

518

bool hasNonInterface = false;

519

if (this.Kind != TypeKind.Enum) {

520

foreach (var part in parts) {

521

var context = part.CreateResolveContext(parentContext).WithCurrentTypeDefinition(this);

522

foreach (var baseTypeRef in part.BaseTypes) {

523

IType baseType = baseTypeRef.Resolve(context);

524

if (!(baseType.Kind == TypeKind.Unknown || result.Contains(baseType))) {

525

result.Add(baseType);

526

if (baseType.Kind != TypeKind.Interface)

527

hasNonInterface = true;

528

}

529

}

530

}

531

}

532

if (!hasNonInterface && !(this.Name == "Object" && this.Namespace == "System" && this.TypeParameterCount == 0)) {

533

KnownTypeCode primitiveBaseType;

534

switch (this.Kind) {

535

case TypeKind.Enum:

536

primitiveBaseType = KnownTypeCode.Enum;

537

break;

538

case TypeKind.Struct:

539

case TypeKind.Void:

540

primitiveBaseType = KnownTypeCode.ValueType;

541

break;

542

case TypeKind.Delegate:

543

primitiveBaseType = KnownTypeCode.Delegate;

544

break;

545

default:

546

primitiveBaseType = KnownTypeCode.Object;

547

break;

548

}

549

IType t = parentContext.Compilation.FindType(primitiveBaseType);

550

if (t.Kind != TypeKind.Unknown)

551

result.Add(t);

552

}

553

return result;

554

}

555

#endregion

556

557

public string FullName {

558

get { return parts[0].FullName; }

559

}

560

561

public string Name {

562

get { return parts[0].Name; }

563

}

564

565

public string ReflectionName {

566

get { return parts[0].ReflectionName; }

567

}

568

569

public string Namespace {

570

get { return parts[0].Namespace; }

571

}

572

573

public DomRegion Region {

574

get { return parts[0].Region; }

575

}

576

577

public DomRegion BodyRegion {

578

get { return parts[0].BodyRegion; }

579

}

580

581

public ITypeDefinition DeclaringTypeDefinition {

582

get { return parentContext.CurrentTypeDefinition; }

583

}

584

585

public IType DeclaringType {

586

get { return parentContext.CurrentTypeDefinition; }

587

}

588

589

public IAssembly ParentAssembly {

590

get { return parentContext.CurrentAssembly; }

591

}

592

593

public virtual DocumentationComment Documentation {

594

get {

595

foreach (var part in parts) {

596

var unresolvedProvider = part.ParsedFile as IUnresolvedDocumentationProvider;

597

if (unresolvedProvider != null) {

598

var doc = unresolvedProvider.GetDocumentation(part, this);

599

if (doc != null)

600

return doc;

601

}

602

}

603

IDocumentationProvider provider = AbstractResolvedEntity.FindDocumentation(parentContext);

604

if (provider != null)

605

return provider.GetDocumentation(this);

606

else

607

return null;

608

}

609

}

610

611

public ICompilation Compilation {

612

get { return parentContext.Compilation; }

613

}

614

615

#region Modifiers

616

public bool IsStatic { get { return isAbstract && isSealed; } }

617

public bool IsAbstract { get { return isAbstract; } }

618

public bool IsSealed { get { return isSealed; } }

619

public bool IsShadowing { get { return isShadowing; } }

620

public bool IsSynthetic { get { return isSynthetic; } }

621

622

public Accessibility Accessibility {

623

get { return accessibility; }

624

}

625

626

bool IHasAccessibility.IsPrivate {

627

get { return accessibility == Accessibility.Private; }

628

}

629

630

bool IHasAccessibility.IsPublic {

631

get { return accessibility == Accessibility.Public; }

632

}

633

634

bool IHasAccessibility.IsProtected {

635

get { return accessibility == Accessibility.Protected; }

636

}

637

638

bool IHasAccessibility.IsInternal {

639

get { return accessibility == Accessibility.Internal; }

640

}

641

642

bool IHasAccessibility.IsProtectedOrInternal {

643

get { return accessibility == Accessibility.ProtectedOrInternal; }

644

}

645

646

bool IHasAccessibility.IsProtectedAndInternal {

647

get { return accessibility == Accessibility.ProtectedAndInternal; }

648

}

649

#endregion

650

651

ITypeDefinition IType.GetDefinition()

652

{

653

return this;

654

}

655

656

IType IType.AcceptVisitor(TypeVisitor visitor)

657

{

658

return visitor.VisitTypeDefinition(this);

659

}

660

661

IType IType.VisitChildren(TypeVisitor visitor)

662

{

663

return this;

664

}

665

666

public ITypeReference ToTypeReference()

667

{

668

ITypeDefinition declTypeDef = this.DeclaringTypeDefinition;

669

if (declTypeDef != null) {

670

return new NestedTypeReference(declTypeDef.ToTypeReference(), this.Name, this.TypeParameterCount - declTypeDef.TypeParameterCount);

671

} else {

672

IAssembly asm = this.ParentAssembly;

673

IAssemblyReference asmRef;

674

if (asm != null)

675

asmRef = new DefaultAssemblyReference(asm.AssemblyName);

676

else

677

asmRef = null;

678

return new GetClassTypeReference(asmRef, this.Namespace, this.Name, this.TypeParameterCount);

679

}

680

}

681

682

public IEnumerable<IType> GetNestedTypes(Predicate<ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None)

683

{

684

const GetMemberOptions opt = GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions;

685

if ((options & opt) == opt) {

686

if (filter == null)

687

return this.NestedTypes;

688

else

689

return GetNestedTypesImpl(filter);

690

} else {

691

return GetMembersHelper.GetNestedTypes(this, filter, options);

692

}

693

}

694

695

IEnumerable<IType> GetNestedTypesImpl(Predicate<ITypeDefinition> filter)

696

{

697

foreach (var nestedType in this.NestedTypes) {

698

if (filter(nestedType))

699

yield return nestedType;

700

}

701

}

702

703

public IEnumerable<IType> GetNestedTypes(IList<IType> typeArguments, Predicate<ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None)

704

{

705

return GetMembersHelper.GetNestedTypes(this, typeArguments, filter, options);

706

}

707

708

#region GetMembers()

709

IEnumerable<IMember> GetFilteredMembers(Predicate<IUnresolvedMember> filter)

710

{

711

var members = GetMemberList();

712

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

713

if (filter == null || filter(members.unresolvedMembers[i])) {

714

yield return members[i];

715

}

716

}

717

for (int i = members.unresolvedMembers.Length; i < members.Count; i++) {

718

var method = (IMethod)members[i];

719

bool ok = false;

720

foreach (var part in method.Parts) {

721

if (filter == null || filter(part)) {

722

ok = true;

723

break;

724

}

725

}

726

if (ok)

727

yield return method;

728

}

729

}

730

731

IEnumerable<IMethod> GetFilteredMethods(Predicate<IUnresolvedMethod> filter)

732

{

733

var members = GetMemberList();

734

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

735

IUnresolvedMethod unresolved = members.unresolvedMembers[i] as IUnresolvedMethod;

736

if (unresolved != null && (filter == null || filter(unresolved))) {

737

yield return (IMethod)members[i];

738

}

739

}

740

for (int i = members.unresolvedMembers.Length; i < members.Count; i++) {

741

var method = (IMethod)members[i];

742

bool ok = false;

743

foreach (var part in method.Parts) {

744

if (filter == null || filter(part)) {

745

ok = true;

746

break;

747

}

748

}

749

if (ok)

750

yield return method;

751

}

752

}

753

754

IEnumerable<TResolved> GetFilteredNonMethods<TUnresolved, TResolved>(Predicate<TUnresolved> filter) where TUnresolved : class, IUnresolvedMember where TResolved : class, IMember

755

{

756

var members = GetMemberList();

757

for (int i = 0; i < members.unresolvedMembers.Length; i++) {

758

TUnresolved unresolved = members.unresolvedMembers[i] as TUnresolved;

759

if (unresolved != null && (filter == null || filter(unresolved))) {

760

yield return (TResolved)members[i];

761

}

762

}

763

}

764

765

public virtual IEnumerable<IMethod> GetMethods(Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.None)

766

{

767

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

768

return GetFilteredMethods(Utils.ExtensionMethods.And(m => !m.IsConstructor, filter));

769

} else {

770

return GetMembersHelper.GetMethods(this, filter, options);

771

}

772

}

773

774

public virtual IEnumerable<IMethod> GetMethods(IList<IType> typeArguments, Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.None)

775

{

776

return GetMembersHelper.GetMethods(this, typeArguments, filter, options);

777

}

778

779

public virtual IEnumerable<IMethod> GetConstructors(Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers)

780

{

781

if (ComHelper.IsComImport(this)) {

782

IType coClass = ComHelper.GetCoClass(this);

783

using (var busyLock = BusyManager.Enter(this)) {

784

if (busyLock.Success) {

785

return coClass.GetConstructors(filter, options)

786

.Select(m => new SpecializedMethod(m, TypeParameterSubstitution.Identity) { DeclaringType = this });

787

}

788

}

789

return EmptyList<IMethod>.Instance;

790

}

791

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

792

return GetFilteredMethods(Utils.ExtensionMethods.And(m => m.IsConstructor && !m.IsStatic, filter));

793

} else {

794

return GetMembersHelper.GetConstructors(this, filter, options);

795

}

796

}

797

798

public virtual IEnumerable<IProperty> GetProperties(Predicate<IUnresolvedProperty> filter = null, GetMemberOptions options = GetMemberOptions.None)

799

{

800

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

801

return GetFilteredNonMethods<IUnresolvedProperty, IProperty>(filter);

802

} else {

803

return GetMembersHelper.GetProperties(this, filter, options);

804

}

805

}

806

807

public virtual IEnumerable<IField> GetFields(Predicate<IUnresolvedField> filter = null, GetMemberOptions options = GetMemberOptions.None)

808

{

809

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

810

return GetFilteredNonMethods<IUnresolvedField, IField>(filter);

811

} else {

812

return GetMembersHelper.GetFields(this, filter, options);

813

}

814

}

815

816

public virtual IEnumerable<IEvent> GetEvents(Predicate<IUnresolvedEvent> filter = null, GetMemberOptions options = GetMemberOptions.None)

817

{

818

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

819

return GetFilteredNonMethods<IUnresolvedEvent, IEvent>(filter);

820

} else {

821

return GetMembersHelper.GetEvents(this, filter, options);

822

}

823

}

824

825

public virtual IEnumerable<IMember> GetMembers(Predicate<IUnresolvedMember> filter = null, GetMemberOptions options = GetMemberOptions.None)

826

{

827

if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) {

828

return GetFilteredMembers(filter);

829

} else {

830

return GetMembersHelper.GetMembers(this, filter, options);

831

}

832

}

833

#endregion

834

835

public bool Equals(IType other)

836

{

837

return this == other;

838

}

839

840

public override string ToString()

841

{

842

return this.ReflectionName;

843

}

844

}

845

}

Older »