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

public CSharpCompletionEngine(IDocument document, ICompletionDataFactory factory, IProjectContent content, CSharpTypeResolveContext ctx, CompilationUnit unit, CSharpParsedFile parsedFile) : base (content, ctx, unit, parsedFile)

{

if (document == null) {

throw new ArgumentNullException("document");

}

if (factory == null) {

throw new ArgumentNullException("factory");

}

this.document = document;

this.factory = factory;

// Set defaults for additional input properties

this.FormattingPolicy = FormattingOptionsFactory.CreateMono();

this.EolMarker = Environment.NewLine;

this.IndentString = "\t";

}

public bool TryGetCompletionWord(int offset, out int startPos, out int wordLength)

{

startPos = wordLength = 0;

int pos = offset - 1;

while (pos >= 0) {

char c = document.GetCharAt(pos);

if (!char.IsLetterOrDigit(c) && c != '_')

break;

pos--;

}

if (pos == -1)

return false;

pos++;

startPos = pos;

while (pos < document.TextLength) {

char c = document.GetCharAt(pos);

if (!char.IsLetterOrDigit(c) && c != '_')

break;

pos++;

}

wordLength = pos - startPos;

return true;

100

}

101

102

public IEnumerable<ICompletionData> GetCompletionData(int offset, bool controlSpace)

103

{

104

this.AutoCompleteEmptyMatch = true;

105

this.AutoSelect = true;

106

this.DefaultCompletionString = null;

107

SetOffset(offset);

108

if (offset > 0) {

109

char lastChar = document.GetCharAt(offset - 1);

110

var result = MagicKeyCompletion(lastChar, controlSpace) ?? Enumerable.Empty<ICompletionData>();

111

if (controlSpace && char.IsWhiteSpace(lastChar)) {

112

offset -= 2;

113

while (offset >= 0 && char.IsWhiteSpace (document.GetCharAt (offset))) {

114

offset--;

115

}

116

if (offset > 0) {

117

var nonWsResult = MagicKeyCompletion(

118

document.GetCharAt(offset),

119

controlSpace

120

);

121

if (nonWsResult != null) {

122

var text = new HashSet<string>(result.Select(r => r.CompletionText));

123

result = result.Concat(nonWsResult.Where(r => !text.Contains(r.CompletionText)));

124

}

125

}

126

}

127

128

return result;

129

}

130

return Enumerable.Empty<ICompletionData>();

131

}

132

133

IEnumerable<string> GenerateNameProposals(AstType type)

134

{

135

if (type is PrimitiveType) {

136

var pt = (PrimitiveType)type;

137

switch (pt.Keyword) {

138

case "object":

139

yield return "o";

140

yield return "obj";

141

break;

142

case "bool":

143

yield return "b";

144

yield return "pred";

145

break;

146

case "double":

147

case "float":

148

case "decimal":

149

yield return "d";

150

yield return "f";

151

yield return "m";

152

break;

153

default:

154

yield return "i";

155

yield return "j";

156

yield return "k";

157

break;

158

}

159

yield break;

160

}

161

string name;

162

if (type is SimpleType) {

163

name = ((SimpleType)type).Identifier;

164

} else if (type is MemberType) {

165

name = ((SimpleType)type).Identifier;

166

} else {

167

yield break;

168

}

169

170

var names = WordParser.BreakWords(name);

171

172

var possibleName = new StringBuilder();

173

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

174

possibleName.Length = 0;

175

for (int j = i; j < names.Count; j++) {

176

if (string.IsNullOrEmpty(names [j])) {

177

continue;

178

}

179

if (j == i) {

180

names [j] = Char.ToLower(names [j] [0]) + names [j].Substring(1);

181

}

182

possibleName.Append(names [j]);

183

}

184

yield return possibleName.ToString();

185

}

186

}

187

188

IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr)

189

{

190

if (expr == null)

191

return null;

192

193

// do not complete <number>. (but <number>.<number>.)

194

if (expr.Node is PrimitiveExpression) {

195

var pexpr = (PrimitiveExpression)expr.Node;

196

if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) {

197

return null;

198

}

199

}

200

var resolveResult = ResolveExpression(expr);

201

if (resolveResult == null) {

202

return null;

203

}

204

if (expr.Node is AstType) {

205

// need to look at paren.parent because of "catch (<Type>.A" expression

206

if (expr.Node.Parent != null && expr.Node.Parent.Parent is CatchClause)

207

return HandleCatchClauseType(expr);

208

return CreateTypeAndNamespaceCompletionData(

209

location,

210

resolveResult.Item1,

211

expr.Node,

212

resolveResult.Item2

213

);

214

}

215

return CreateCompletionData(

216

location,

217

resolveResult.Item1,

218

expr.Node,

219

resolveResult.Item2

220

);

221

}

222

223

bool IsInPreprocessorDirective()

224

{

225

var text = GetMemberTextToCaret().Item1;

226

var miniLexer = new MiniLexer(text);

227

miniLexer.Parse();

228

return miniLexer.IsInPreprocessorDirective;

229

}

230

231

IEnumerable<ICompletionData> HandleObjectInitializer(CompilationUnit unit, AstNode n)

232

{

233

var p = n.Parent;

234

while (p != null && !(p is ObjectCreateExpression)) {

235

p = p.Parent;

236

}

237

var parent = (ArrayInitializerExpression)n.Parent;

238

if (parent.IsSingleElement)

239

parent = (ArrayInitializerExpression)parent.Parent;

240

if (p != null) {

241

var contextList = new CompletionDataWrapper(this);

242

var initializerResult = ResolveExpression(p, unit);

243

if (initializerResult != null && initializerResult.Item1.Type.Kind != TypeKind.Unknown) {

244

// check 3 cases:

245

// 1) New initalizer { xpr

246

// 2) Object initializer { prop = val1, field = val2, xpr

247

// 3) Array initializer { new Foo (), a, xpr

248

// in case 1 all object/array initializer options should be given - in the others not.

249

250

AstNode prev = null;

251

if (parent.Elements.Count > 1) {

252

prev = parent.Elements.First();

253

if (prev is ArrayInitializerExpression && ((ArrayInitializerExpression)prev).IsSingleElement)

254

prev = ((ArrayInitializerExpression)prev).Elements.FirstOrDefault();

255

}

256

257

if (prev != null && !(prev is NamedExpression)) {

258

AddContextCompletion(contextList, GetState(), n, unit);

259

// case 3)

260

return contextList.Result;

261

}

262

263

foreach (var m in initializerResult.Item1.Type.GetMembers (m => m.IsPublic && (m.EntityType == EntityType.Property || m.EntityType == EntityType.Field))) {

264

contextList.AddMember(m);

265

}

266

267

if (prev != null && (prev is NamedExpression)) {

268

// case 2)

269

return contextList.Result;

270

}

271

272

// case 1)

273

274

// check if the object is a list, if not only provide object initalizers

275

var list = typeof(System.Collections.IList).ToTypeReference().Resolve(Compilation);

276

if (initializerResult.Item1.Type.Kind != TypeKind.Array && list != null) {

277

var def = initializerResult.Item1.Type.GetDefinition();

278

if (def != null && !def.IsDerivedFrom(list.GetDefinition()))

279

return contextList.Result;

280

}

281

282

AddContextCompletion(contextList, GetState(), n, unit);

283

return contextList.Result;

284

}

285

}

286

return null;

287

}

288

289

IEnumerable<ICompletionData> MagicKeyCompletion(char completionChar, bool controlSpace)

290

{

291

Tuple<ResolveResult, CSharpResolver> resolveResult;

292

switch (completionChar) {

293

// Magic key completion

294

case ':':

295

case '.':

296

if (IsInsideCommentStringOrDirective()) {

297

return Enumerable.Empty<ICompletionData>();

298

}

299

return HandleMemberReferenceCompletion(GetExpressionBeforeCursor());

300

case '#':

301

if (!IsInPreprocessorDirective())

302

return null;

303

return GetDirectiveCompletionData();

304

// XML doc completion

305

case '<':

306

if (IsInsideDocComment()) {

307

return GetXmlDocumentationCompletionData();

308

}

309

if (controlSpace) {

310

return DefaultControlSpaceItems();

311

}

312

return null;

313

case '>':

314

if (!IsInsideDocComment()) {

315

return null;

316

}

317

string lineText = document.GetText(document.GetLineByNumber(location.Line));

318

int startIndex = Math.Min(location.Column - 1, lineText.Length - 1);

319

320

while (startIndex >= 0 && lineText [startIndex] != '<') {

321

--startIndex;

322

if (lineText [startIndex] == '/') {

323

// already closed.

324

startIndex = -1;

325

break;

326

}

327

}

328

329

if (startIndex >= 0) {

330

int endIndex = startIndex;

331

while (endIndex <= location.Column && endIndex < lineText.Length && !Char.IsWhiteSpace (lineText [endIndex])) {

332

endIndex++;

333

}

334

string tag = endIndex - startIndex - 1 > 0 ? lineText.Substring(

335

startIndex + 1,

336

endIndex - startIndex - 2

337

) : null;

338

if (!string.IsNullOrEmpty(tag) && commentTags.IndexOf(tag) >= 0) {

339

document.Insert(offset, "</" + tag + ">");

340

}

341

}

342

return null;

343

344

// Parameter completion

345

case '(':

346

if (IsInsideCommentStringOrDirective()) {

347

return null;

348

}

349

var invoke = GetInvocationBeforeCursor(true);

350

if (invoke == null) {

351

if (controlSpace)

352

return DefaultControlSpaceItems(invoke);

353

return null;

354

}

355

if (invoke.Node is TypeOfExpression) {

356

return CreateTypeList();

357

}

358

var invocationResult = ResolveExpression(invoke);

359

if (invocationResult == null) {

360

return null;

361

}

362

var methodGroup = invocationResult.Item1 as MethodGroupResolveResult;

363

if (methodGroup != null) {

364

return CreateParameterCompletion(

365

methodGroup,

366

invocationResult.Item2,

367

invoke.Node,

368

invoke.Unit,

369

370

controlSpace

371

);

372

}

373

374

if (controlSpace) {

375

return DefaultControlSpaceItems(invoke);

376

}

377

return null;

378

case '=':

379

return controlSpace ? DefaultControlSpaceItems() : null;

380

case ',':

381

int cpos2;

382

if (!GetParameterCompletionCommandOffset(out cpos2)) {

383

return null;

384

}

385

// completionContext = CompletionWidget.CreateCodeCompletionContext (cpos2);

386

// int currentParameter2 = MethodParameterDataProvider.GetCurrentParameterIndex (CompletionWidget, completionContext) - 1;

387

// return CreateParameterCompletion (CreateResolver (), location, ExpressionContext.MethodBody, provider.Methods, currentParameter);

388

break;

389

390

// Completion on space:

391

case ' ':

392

int tokenIndex = offset;

393

string token = GetPreviousToken(ref tokenIndex, false);

394

if (IsInsideCommentStringOrDirective()) {

395

if (IsInPreprocessorDirective())

396

return HandleKeywordCompletion(tokenIndex, token);

397

return null;

398

}

399

// check propose name, for context <variable name> <ctrl+space> (but only in control space context)

400

//IType isAsType = null;

401

var isAsExpression = GetExpressionAt(offset);

402

if (controlSpace && isAsExpression != null && isAsExpression.Node is VariableDeclarationStatement && token != "new") {

403

var parent = isAsExpression.Node as VariableDeclarationStatement;

404

var proposeNameList = new CompletionDataWrapper(this);

405

if (parent.Variables.Count != 1)

406

return DefaultControlSpaceItems(isAsExpression, controlSpace);

407

408

foreach (var possibleName in GenerateNameProposals (parent.Type)) {

409

if (possibleName.Length > 0) {

410

proposeNameList.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));

411

}

412

}

413

414

AutoSelect = false;

415

AutoCompleteEmptyMatch = false;

416

return proposeNameList.Result;

417

}

418

// int tokenIndex = offset;

419

// string token = GetPreviousToken (ref tokenIndex, false);

420

// if (result.ExpressionContext == ExpressionContext.ObjectInitializer) {

421

// resolver = CreateResolver ();

422

// ExpressionContext exactContext = new NewCSharpExpressionFinder (dom).FindExactContextForObjectInitializer (document, resolver.Unit, Document.FileName, resolver.CallingType);

423

// IReturnType objectInitializer = ((ExpressionContext.TypeExpressionContext)exactContext).UnresolvedType;

424

// if (objectInitializer != null && objectInitializer.ArrayDimensions == 0 && objectInitializer.PointerNestingLevel == 0 && (token == "{" || token == ","))

425

// return CreateCtrlSpaceCompletionData (completionContext, result);

426

// }

427

if (token == "=") {

428

int j = tokenIndex;

429

string prevToken = GetPreviousToken(ref j, false);

430

if (prevToken == "=" || prevToken == "+" || prevToken == "-") {

431

token = prevToken + token;

432

tokenIndex = j;

433

}

434

}

435

switch (token) {

436

case "(":

437

case ",":

438

int cpos;

439

if (!GetParameterCompletionCommandOffset(out cpos)) {

440

break;

441

}

442

int currentParameter = GetCurrentParameterIndex(cpos - 1, this.offset) - 1;

443

if (currentParameter < 0) {

444

return null;

445

}

446

invoke = GetInvocationBeforeCursor(token == "(");

447

if (invoke == null) {

448

return null;

449

}

450

invocationResult = ResolveExpression(invoke);

451

if (invocationResult == null) {

452

return null;

453

}

454

methodGroup = invocationResult.Item1 as MethodGroupResolveResult;

455

if (methodGroup != null) {

456

return CreateParameterCompletion(

457

methodGroup,

458

invocationResult.Item2,

459

invoke.Node,

460

invoke.Unit,

461

currentParameter,

462

controlSpace);

463

}

464

return null;

465

case "=":

466

case "==":

467

GetPreviousToken(ref tokenIndex, false);

468

var expressionOrVariableDeclaration = GetExpressionAt(tokenIndex);

469

if (expressionOrVariableDeclaration == null) {

470

return null;

471

}

472

473

resolveResult = ResolveExpression(expressionOrVariableDeclaration);

474

475

if (resolveResult == null) {

476

return null;

477

}

478

if (resolveResult.Item1.Type.Kind == TypeKind.Enum) {

479

var wrapper = new CompletionDataWrapper(this);

480

AddContextCompletion(

481

wrapper,

482

resolveResult.Item2,

483

expressionOrVariableDeclaration.Node,

484

expressionOrVariableDeclaration.Unit);

485

AddEnumMembers(wrapper, resolveResult.Item1.Type, resolveResult.Item2);

486

AutoCompleteEmptyMatch = false;

487

return wrapper.Result;

488

}

489

490

// if (resolvedType.FullName == DomReturnType.Bool.FullName) {

491

// CompletionDataList completionList = new ProjectDomCompletionDataList ();

492

// CompletionDataCollector cdc = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location);

493

// completionList.AutoCompleteEmptyMatch = false;

494

// cdc.Add ("true", "md-keyword");

495

// cdc.Add ("false", "md-keyword");

496

// resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc);

497

// return completionList;

498

// }

499

// if (resolvedType.ClassType == ClassType.Delegate && token == "=") {

500

// CompletionDataList completionList = new ProjectDomCompletionDataList ();

501

// string parameterDefinition = AddDelegateHandlers (completionList, resolvedType);

502

// string varName = GetPreviousMemberReferenceExpression (tokenIndex);

503

// completionList.Add (new EventCreationCompletionData (document, varName, resolvedType, null, parameterDefinition, resolver.CallingMember, resolvedType));

504

505

// CompletionDataCollector cdc = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location);

506

// resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc);

507

// foreach (var data in completionList) {

508

// if (data is MemberCompletionData)

509

// ((MemberCompletionData)data).IsDelegateExpected = true;

510

// }

511

// return completionList;

512

// }

513

return null;

514

case "+=":

515

case "-=":

516

GetPreviousToken(ref tokenIndex, false);

517

518

expressionOrVariableDeclaration = GetExpressionAt(tokenIndex);

519

if (expressionOrVariableDeclaration == null) {

520

return null;

521

}

522

523

resolveResult = ResolveExpression(expressionOrVariableDeclaration);

524

if (resolveResult == null) {

525

return null;

526

}

527

528

529

var mrr = resolveResult.Item1 as MemberResolveResult;

530

if (mrr != null) {

531

var evt = mrr.Member as IEvent;

532

if (evt == null) {

533

return null;

534

}

535

var delegateType = evt.ReturnType;

536

if (delegateType.Kind != TypeKind.Delegate) {

537

return null;

538

}

539

540

var wrapper = new CompletionDataWrapper(this);

541

if (currentType != null) {

542

// bool includeProtected = DomType.IncludeProtected (dom, typeFromDatabase, resolver.CallingType);

543

foreach (var method in currentType.Methods) {

544

if (MatchDelegate(delegateType, method) /*&& method.IsAccessibleFrom (dom, resolver.CallingType, resolver.CallingMember, includeProtected) &&*/) {

545

wrapper.AddMember(method);

546

// data.SetText (data.CompletionText + ";");

547

}

548

}

549

}

550

if (token == "+=") {

551

string parameterDefinition = AddDelegateHandlers(

552

wrapper,

553

delegateType

554

);

555

string varName = GetPreviousMemberReferenceExpression(tokenIndex);

556

wrapper.Result.Add(

557

factory.CreateEventCreationCompletionData(

558

varName,

559

delegateType,

560

evt,

561

parameterDefinition,

562

currentMember,

563

currentType)

564

);

565

}

566

567

return wrapper.Result;

568

}

569

return null;

570

case ":":

571

if (currentMember == null) {

572

token = GetPreviousToken(ref tokenIndex, false);

573

token = GetPreviousToken(ref tokenIndex, false);

574

if (token == "enum")

575

return HandleEnumContext();

576

var wrapper = new CompletionDataWrapper(this);

577

578

AddTypesAndNamespaces(

579

wrapper,

580

GetState(),

581

null,

582

t => currentType != null && !currentType.ReflectionName.Equals(t.ReflectionName) ? t : null

583

);

584

return wrapper.Result;

585

}

586

return null;

587

}

588

589

var keywordCompletion = HandleKeywordCompletion(tokenIndex, token);

590

if (keywordCompletion == null && controlSpace) {

591

goto default;

592

}

593

return keywordCompletion;

594

// Automatic completion

595

default:

596

if (IsInsideCommentStringOrDirective()) {

597

return null;

598

}

599

if (IsInLinqContext(offset)) {

600

if (!controlSpace && !(char.IsLetter(completionChar) || completionChar == '_')) {

601

return null;

602

}

603

tokenIndex = offset;

604

token = GetPreviousToken(ref tokenIndex, false);

605

// token last typed

606

if (!char.IsWhiteSpace(completionChar) && !linqKeywords.Contains(token)) {

607

token = GetPreviousToken(ref tokenIndex, false);

608

}

609

// token last typed

610

611

if (linqKeywords.Contains(token)) {

612

if (token == "from") {

613

// after from no auto code completion.

614

return null;

615

}

616

return DefaultControlSpaceItems();

617

}

618

var dataList = new CompletionDataWrapper(this);

619

AddKeywords(dataList, linqKeywords);

620

return dataList.Result;

621

}

622

if (currentType != null && currentType.Kind == TypeKind.Enum) {

623

return HandleEnumContext();

624

}

625

var contextList = new CompletionDataWrapper(this);

626

var identifierStart = GetExpressionAtCursor();

627

if (identifierStart != null) {

628

if (identifierStart.Node is TypeParameterDeclaration) {

629

return null;

630

}

631

632

if (identifierStart.Node is MemberReferenceExpression) {

633

return HandleMemberReferenceCompletion(

634

new ExpressionResult(

635

((MemberReferenceExpression)identifierStart.Node).Target,

636

identifierStart.Unit

637

)

638

);

639

}

640

641

if (identifierStart.Node is Identifier) {

642

// May happen in variable names

643

return controlSpace ? DefaultControlSpaceItems(identifierStart) : null;

644

}

645

if (identifierStart.Node is VariableInitializer && location <= ((VariableInitializer)identifierStart.Node).NameToken.EndLocation) {

646

return controlSpace ? HandleAccessorContext() ?? DefaultControlSpaceItems(identifierStart) : null;

647

}

648

649

if (identifierStart.Node is CatchClause) {

650

if (((CatchClause)identifierStart.Node).VariableNameToken.Contains(location)) {

651

return null;

652

}

653

return HandleCatchClauseType(identifierStart);

654

}

655

}

656

if (!(char.IsLetter(completionChar) || completionChar == '_') && (!controlSpace || identifierStart == null || !(identifierStart.Node.Parent is ArrayInitializerExpression))) {

657

return controlSpace ? HandleAccessorContext() ?? DefaultControlSpaceItems(identifierStart) : null;

658

}

659

660

char prevCh = offset > 2 ? document.GetCharAt(offset - 2) : ';';

661

char nextCh = offset < document.TextLength ? document.GetCharAt(offset) : ' ';

662

const string allowedChars = ";,.[](){}+-*/%^?:&|~!<>=";

663

if (!Char.IsWhiteSpace(nextCh) && allowedChars.IndexOf(nextCh) < 0) {

664

return null;

665

}

666

if (!(Char.IsWhiteSpace(prevCh) || allowedChars.IndexOf(prevCh) >= 0)) {

667

return null;

668

}

669

670

// Do not pop up completion on identifier identifier (should be handled by keyword completion).

671

tokenIndex = offset - 1;

672

token = GetPreviousToken(ref tokenIndex, false);

673

if (token == "class" || token == "interface" || token == "struct" || token == "enum" || token == "namespace") {

674

// after these always follows a name

675

return null;

676

}

677

var keywordresult = HandleKeywordCompletion(tokenIndex, token);

678

if (keywordresult != null) {

679

return keywordresult;

680

}

681

682

int prevTokenIndex = tokenIndex;

683

var prevToken2 = GetPreviousToken(ref prevTokenIndex, false);

684

if (prevToken2 == "delegate") {

685

// after these always follows a name

686

return null;

687

}

688

689

if (identifierStart == null && !string.IsNullOrEmpty(token) && !IsInsideCommentStringOrDirective() && (prevToken2 == ";" || prevToken2 == "{" || prevToken2 == "}")) {

690

char last = token [token.Length - 1];

691

if (char.IsLetterOrDigit(last) || last == '_' || token == ">") {

692

return HandleKeywordCompletion(tokenIndex, token);

693

}

694

}

695

696

if (identifierStart == null) {

697

var accCtx = HandleAccessorContext();

698

if (accCtx != null) {

699

return accCtx;

700

}

701

return DefaultControlSpaceItems(null, controlSpace);

702

}

703

CSharpResolver csResolver;

704

AstNode n = identifierStart.Node;

705

if (n != null && n.Parent is AnonymousTypeCreateExpression) {

706

AutoSelect = false;

707

}

708

709

// Handle foreach (type name _

710

if (n is IdentifierExpression) {

711

var prev = n.GetPrevNode() as ForeachStatement;

712

if (prev != null && prev.InExpression.IsNull) {

713

if (controlSpace) {

714

contextList.AddCustom("in");

715

return contextList.Result;

716

}

717

return null;

718

}

719

720

// var astResolver = new CSharpAstResolver(

721

// GetState(),

722

// identifierStart.Unit,

723

// CSharpParsedFile

724

// );

725

726

// foreach (var type in CreateFieldAction.GetValidTypes(astResolver, (Expression)n)) {

727

// if (type.Kind == TypeKind.Delegate) {

728

// AddDelegateHandlers(contextList, type, false, false);

729

// AutoSelect = false;

730

// AutoCompleteEmptyMatch = false;

731

// }

732

// }

733

}

734

735

// Handle object/enumerable initialzer expressions: "new O () { P$"

736

if (n is IdentifierExpression && n.Parent is ArrayInitializerExpression) {

737

var result = HandleObjectInitializer(identifierStart.Unit, n);

738

if (result != null)

739

return result;

740

}

741

742

if (n != null && n.Parent is InvocationExpression) {

743

var invokeParent = (InvocationExpression)n.Parent;

744

var invokeResult = ResolveExpression(

745

invokeParent.Target,

746

identifierStart.Unit

747

);

748

var mgr = invokeResult != null ? invokeResult.Item1 as MethodGroupResolveResult : null;

749

if (mgr != null) {

750

int idx = 0;

751

foreach (var arg in invokeParent.Arguments) {

752

if (arg == n) {

753

break;

754

}

755

idx++;

756

}

757

758

foreach (var method in mgr.Methods) {

759

if (idx < method.Parameters.Count && method.Parameters [idx].Type.Kind == TypeKind.Delegate) {

760

AutoSelect = false;

761

AutoCompleteEmptyMatch = false;

762

}

763

foreach (var p in method.Parameters) {

764

contextList.AddNamedParameterVariable(p);

765

}

766

}

767

idx++;

768

foreach (var list in mgr.GetExtensionMethods ()) {

769

foreach (var method in list) {

770

if (idx < method.Parameters.Count && method.Parameters [idx].Type.Kind == TypeKind.Delegate) {

771

AutoSelect = false;

772

AutoCompleteEmptyMatch = false;

773

}

774

}

775

}

776

}

777

}

778

779

if (n != null && n.Parent is ObjectCreateExpression) {

780

var invokeResult = ResolveExpression(n.Parent, identifierStart.Unit);

781

var mgr = invokeResult != null ? invokeResult.Item1 as ResolveResult : null;

782

if (mgr != null) {

783

foreach (var constructor in mgr.Type.GetConstructors ()) {

784

foreach (var p in constructor.Parameters) {

785

contextList.AddVariable(p);

786

}

787

}

788

}

789

}

790

791

if (n is IdentifierExpression) {

792

var bop = n.Parent as BinaryOperatorExpression;

793

Expression evaluationExpr = null;

794

795

if (bop != null && bop.Right == n && (bop.Operator == BinaryOperatorType.Equality || bop.Operator == BinaryOperatorType.InEquality)) {

796

evaluationExpr = bop.Left;

797

}

798

// check for compare to enum case

799

if (evaluationExpr != null) {

800

resolveResult = ResolveExpression(evaluationExpr, identifierStart.Unit);

801

if (resolveResult != null && resolveResult.Item1.Type.Kind == TypeKind.Enum) {

802

var wrapper = new CompletionDataWrapper(this);

803

AddContextCompletion(

804

wrapper,

805

resolveResult.Item2,

806

evaluationExpr,

807

identifierStart.Unit

808

);

809

AddEnumMembers(wrapper, resolveResult.Item1.Type, resolveResult.Item2);

810

AutoCompleteEmptyMatch = false;

811

return wrapper.Result;

812

}

813

}

814

}

815

816

if (n is Identifier && n.Parent is ForeachStatement) {

817

if (controlSpace) {

818

return DefaultControlSpaceItems();

819

}

820

return null;

821

}

822

823

if (n is ArrayInitializerExpression) {

824

// check for new [] {...} expression -> no need to resolve the type there

825

var parent = n.Parent as ArrayCreateExpression;

826

if (parent != null && parent.Type.IsNull) {

827

return DefaultControlSpaceItems();

828

}

829

830

var initalizerResult = ResolveExpression(n.Parent, identifierStart.Unit);

831

832

var concreteNode = identifierStart.Unit.GetNodeAt<IdentifierExpression>(location);

833

// check if we're on the right side of an initializer expression

834

if (concreteNode != null && concreteNode.Parent != null && concreteNode.Parent.Parent != null && concreteNode.Identifier != "a" && concreteNode.Parent.Parent is NamedExpression) {

835

return DefaultControlSpaceItems();

836

}

837

if (initalizerResult != null && initalizerResult.Item1.Type.Kind != TypeKind.Unknown) {

838

839

foreach (var property in initalizerResult.Item1.Type.GetProperties ()) {

840

if (!property.IsPublic) {

841

continue;

842

}

843

contextList.AddMember(property);

844

}

845

foreach (var field in initalizerResult.Item1.Type.GetFields ()) {

846

if (!field.IsPublic) {

847

continue;

848

}

849

contextList.AddMember(field);

850

}

851

return contextList.Result;

852

}

853

return DefaultControlSpaceItems();

854

}

855

if (IsAttributeContext(n)) {

856

// add attribute targets

857

if (currentType == null) {

858

contextList.AddCustom("assembly");

859

contextList.AddCustom("module");

860

contextList.AddCustom("type");

861

} else {

862

contextList.AddCustom("param");

863

contextList.AddCustom("field");

864

contextList.AddCustom("property");

865

contextList.AddCustom("method");

866

contextList.AddCustom("event");

867

}

868

contextList.AddCustom("return");

869

}

870

if (n is MemberType) {

871

resolveResult = ResolveExpression(

872

((MemberType)n).Target,

873

identifierStart.Unit

874

);

875

return CreateTypeAndNamespaceCompletionData(

876

location,

877

resolveResult.Item1,

878

((MemberType)n).Target,

879

resolveResult.Item2

880

);

881

}

882

if (n != null/* && !(identifierStart.Item2 is TypeDeclaration)*/) {

883

csResolver = new CSharpResolver(ctx);

884

var nodes = new List<AstNode>();

885

nodes.Add(n);

886

if (n.Parent is ICSharpCode.NRefactory.CSharp.Attribute) {

887

nodes.Add(n.Parent);

888

}

889

var astResolver = new CSharpAstResolver(

890

csResolver,

891

identifierStart.Unit,

892

CSharpParsedFile

893

);

894

astResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(nodes));

895

try {

896

csResolver = astResolver.GetResolverStateBefore(n);

897

} catch (Exception) {

898

csResolver = GetState();

899

}

900

// add attribute properties.

901

if (n.Parent is ICSharpCode.NRefactory.CSharp.Attribute) {

902

var resolved = astResolver.Resolve(n.Parent);

903

if (resolved != null && resolved.Type != null) {

904

foreach (var property in resolved.Type.GetProperties (p => p.Accessibility == Accessibility.Public)) {

905

contextList.AddMember(property);

906

}

907

foreach (var field in resolved.Type.GetFields (p => p.Accessibility == Accessibility.Public)) {

908

contextList.AddMember(field);

909

}

910

}

911

}

912

} else {

913

csResolver = GetState();

914

}

915

// identifier has already started with the first letter

916

offset--;

917

AddContextCompletion(

918

contextList,

919

csResolver,

920

identifierStart.Node,

921

identifierStart.Unit

922

);

923

return contextList.Result;

924

// if (stub.Parent is BlockStatement)

925

926

// result = FindExpression (dom, completionContext, -1);

927

// if (result == null)

928

// return null;

929

// else if (result.ExpressionContext != ExpressionContext.IdentifierExpected) {

930

// triggerWordLength = 1;

931

// bool autoSelect = true;

932

// IType returnType = null;

933

// if ((prevCh == ',' || prevCh == '(') && GetParameterCompletionCommandOffset (out cpos)) {

934

// ctx = CompletionWidget.CreateCodeCompletionContext (cpos);

935

// NRefactoryParameterDataProvider dataProvider = ParameterCompletionCommand (ctx) as NRefactoryParameterDataProvider;

936

// if (dataProvider != null) {

937

// int i = dataProvider.GetCurrentParameterIndex (CompletionWidget, ctx) - 1;

938

// foreach (var method in dataProvider.Methods) {

939

// if (i < method.Parameters.Count) {

940

// returnType = dom.GetType (method.Parameters [i].ReturnType);

941

// autoSelect = returnType == null || returnType.ClassType != ClassType.Delegate;

942

// break;

943

// }

944

// }

945

// }

946

// }

947

// // Bug 677531 - Auto-complete doesn't always highlight generic parameter in method signature

948

// //if (result.ExpressionContext == ExpressionContext.TypeName)

949

// // autoSelect = false;

950

// CompletionDataList dataList = CreateCtrlSpaceCompletionData (completionContext, result);

951

// AddEnumMembers (dataList, returnType);

952

// dataList.AutoSelect = autoSelect;

953

// return dataList;

954

// } else {

955

// result = FindExpression (dom, completionContext, 0);

956

// tokenIndex = offset;

957

958

// // check foreach case, unfortunately the expression finder is too dumb to handle full type names

959

// // should be overworked if the expression finder is replaced with a mcs ast based analyzer.

960

// var possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // starting letter

961

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varname

962

963

// // read return types to '(' token

964

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varType

965

// if (possibleForeachToken == ">") {

966

// while (possibleForeachToken != null && possibleForeachToken != "(") {

967

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false);

968

// }

969

// } else {

970

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // (

971

// if (possibleForeachToken == ".")

972

// while (possibleForeachToken != null && possibleForeachToken != "(")

973

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false);

974

// }

975

// possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // foreach

976

977

// if (possibleForeachToken == "foreach") {

978

// result.ExpressionContext = ExpressionContext.ForeachInToken;

979

// } else {

980

// return null;

981

// // result.ExpressionContext = ExpressionContext.IdentifierExpected;

982

// }

983

// result.Expression = "";

984

// result.Region = DomRegion.Empty;

985

986

// return CreateCtrlSpaceCompletionData (completionContext, result);

987

// }

988

// break;

989

}

990

return null;

991

}

992

993

IEnumerable<ICompletionData> HandleCatchClauseType(ExpressionResult identifierStart)

994

{

995

Func<IType, IType> typePred = delegate (IType type) {

996

if (type.GetAllBaseTypes().Any(t => t.ReflectionName == "System.Exception"))

997

return type;

998

return null;

999

};

1000

if (identifierStart.Node is CatchClause) {

1001

var wrapper = new CompletionDataWrapper(this);

1002

AddTypesAndNamespaces(

1003

wrapper,

1004

GetState(),

1005

identifierStart.Node,

1006

typePred,

1007

m => false

1008

);

1009

return wrapper.Result;

1010

}

1011

1012

var resolveResult = ResolveExpression(identifierStart);

1013

return CreateCompletionData(

1014

location,

1015

resolveResult.Item1,

1016

identifierStart.Node,

1017

resolveResult.Item2,

1018

typePred

1019

);

1020

}

1021

1022

string[] validEnumBaseTypes = {

1023

"byte",

1024

"sbyte",

1025

"short",

1026

"int",

1027

"long",

1028

"ushort",

1029

"uint",

1030

"ulong"

1031

};

1032

1033

IEnumerable<ICompletionData> HandleEnumContext()

1034

{

1035

var cu = ParseStub("a", false);

1036

if (cu == null) {

1037

return null;

1038

}

1039

1040

var curType = cu.GetNodeAt<TypeDeclaration>(location);

1041

if (curType == null || curType.ClassType != ClassType.Enum) {

1042

cu = ParseStub("a {}", false);

1043

var node = cu.GetNodeAt<AstType>(location);

1044

if (node != null) {

1045

var wrapper = new CompletionDataWrapper(this);

1046

AddKeywords(wrapper, validEnumBaseTypes);

1047

return wrapper.Result;

1048

}

1049

}

1050

1051

var member = cu.GetNodeAt<EnumMemberDeclaration>(location);

1052

if (member != null && member.NameToken.EndLocation < location) {

1053

return DefaultControlSpaceItems();

1054

}

1055

return null;

1056

}

1057

1058

bool IsInLinqContext(int offset)

1059

{

1060

string token;

1061

while (null != (token = GetPreviousToken (ref offset, true)) && !IsInsideCommentStringOrDirective ()) {

1062

1063

if (token == "from") {

1064

return !IsInsideCommentStringOrDirective(offset);

1065

}

1066

if (token == ";" || token == "{") {

1067

return false;

1068

}

1069

}

1070

return false;

1071

}

1072

1073

IEnumerable<ICompletionData> HandleAccessorContext()

1074

{

1075

var unit = ParseStub("get; }", false);

1076

var node = unit.GetNodeAt(location, cn => !(cn is CSharpTokenNode));

1077

if (node is Accessor) {

1078

node = node.Parent;

1079

}

1080

var contextList = new CompletionDataWrapper(this);

1081

if (node is PropertyDeclaration) {

1082

contextList.AddCustom("get");

1083

contextList.AddCustom("set");

1084

AddKeywords(contextList, accessorModifierKeywords);

1085

} else if (node is CustomEventDeclaration) {

1086

contextList.AddCustom("add");

1087

contextList.AddCustom("remove");

1088

} else {

1089

return null;

1090

}

1091

1092

return contextList.Result;

1093

}

1094

1095

IEnumerable<ICompletionData> DefaultControlSpaceItems(ExpressionResult xp = null, bool controlSpace = true)

1096

{

1097

var wrapper = new CompletionDataWrapper(this);

1098

if (offset >= document.TextLength) {

1099

offset = document.TextLength - 1;

1100

}

1101

while (offset > 1 && char.IsWhiteSpace (document.GetCharAt (offset))) {

1102

offset--;

1103

}

1104

location = document.GetLocation(offset);

1105

1106

if (xp == null) {

1107

xp = GetExpressionAtCursor();

1108

}

1109

AstNode node;

1110

CompilationUnit unit;

1111

Tuple<ResolveResult, CSharpResolver> rr;

1112

if (xp != null) {

1113

node = xp.Node;

1114

rr = ResolveExpression(node, xp.Unit);

1115

unit = xp.Unit;

1116

} else {

1117

unit = ParseStub("foo", false);

1118

node = unit.GetNodeAt(

1119

location.Line,

1120

location.Column + 2,

1121

n => n is Expression || n is AstType

1122

);

1123

rr = ResolveExpression(node, unit);

1124

}

1125

if (node is Identifier && node.Parent is ForeachStatement) {

1126

var foreachStmt = (ForeachStatement)node.Parent;

1127

foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) {

1128

if (possibleName.Length > 0) {

1129

wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));

1130

}

1131

}

1132

1133

AutoSelect = false;

1134

AutoCompleteEmptyMatch = false;

1135

return wrapper.Result;

1136

}

1137

1138

if (node is Identifier && node.Parent is ParameterDeclaration) {

1139

if (!controlSpace) {

1140

return null;

1141

}

1142

// Try Parameter name case

1143

var param = node.Parent as ParameterDeclaration;

1144

if (param != null) {

1145

foreach (var possibleName in GenerateNameProposals (param.Type)) {

1146

if (possibleName.Length > 0) {

1147

wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));

1148

}

1149

}

1150

AutoSelect = false;

1151

AutoCompleteEmptyMatch = false;

1152

return wrapper.Result;

1153

}

1154

}

1155

if (Unit != null && (node == null || node is TypeDeclaration)) {

1156

var constructor = Unit.GetNodeAt<ConstructorDeclaration>(

1157

location.Line,

1158

location.Column - 3

1159

);

1160

if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) {

1161

wrapper.AddCustom("this");

1162

wrapper.AddCustom("base");

1163

return wrapper.Result;

1164

}

1165

}

1166

1167

var initializer = node != null ? node.Parent as ArrayInitializerExpression : null;

1168

if (initializer != null) {

1169

var result = HandleObjectInitializer(unit, initializer);

1170

if (result != null)

1171

return result;

1172

}

1173

CSharpResolver csResolver = null;

1174

if (rr != null) {

1175

csResolver = rr.Item2;

1176

}

1177

if (csResolver == null) {

1178

if (node != null) {

1179

csResolver = GetState();

1180

//var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpParsedFile);

1181

1182

try {

1183

//csResolver = astResolver.GetResolverStateBefore (node);

1184

Console.WriteLine(csResolver.LocalVariables.Count());

1185

} catch (Exception e) {

1186

Console.WriteLine("E!!!" + e);

1187

}

1188

1189

} else {

1190

csResolver = GetState();

1191

}

1192

}

1193

AddContextCompletion(wrapper, csResolver, node, unit);

1194

1195

return wrapper.Result;

1196

}

1197

1198

void AddContextCompletion(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node, CompilationUnit unit)

1199

{

1200

if (state != null && !(node is AstType)) {

1201

foreach (var variable in state.LocalVariables) {

1202

if (variable.Region.IsInside(location.Line, location.Column - 1)) {

1203

continue;

1204

}

1205

wrapper.AddVariable(variable);

1206

}

1207

}

1208

1209

if (currentMember is IUnresolvedParameterizedMember && !(node is AstType)) {

1210

var param = (IParameterizedMember)currentMember.CreateResolved(ctx);

1211

foreach (var p in param.Parameters) {

1212

wrapper.AddVariable(p);

1213

}

1214

}

1215

1216

if (currentMember is IUnresolvedMethod) {

1217

var method = (IUnresolvedMethod)currentMember;

1218

foreach (var p in method.TypeParameters) {

1219

wrapper.AddTypeParameter(p);

1220

}

1221

}

1222

1223

Func<IType, IType> typePred = null;

1224

if (IsAttributeContext(node)) {

1225

var attribute = Compilation.FindType(KnownTypeCode.Attribute);

1226

typePred = t => {

1227

return t.GetAllBaseTypeDefinitions().Any(bt => bt.Equals(attribute)) ? t : null;

1228

};

1229

}

1230

AddTypesAndNamespaces(wrapper, state, node, typePred);

1231

1232

wrapper.Result.Add(factory.CreateLiteralCompletionData("global"));

1233

1234

if (!(node is AstType)) {

1235

if (currentMember != null || node is Expression) {

1236

AddKeywords(wrapper, statementStartKeywords);

1237

AddKeywords(wrapper, expressionLevelKeywords);

1238

if (node is TypeDeclaration)

1239

AddKeywords(wrapper, typeLevelKeywords);

1240

} else if (currentType != null) {

1241

AddKeywords(wrapper, typeLevelKeywords);

1242

} else {

1243

AddKeywords(wrapper, globalLevelKeywords);

1244

}

1245

var prop = currentMember as IUnresolvedProperty;

1246

if (prop != null && prop.Setter != null && prop.Setter.Region.IsInside(location)) {

1247

wrapper.AddCustom("value");

1248

}

1249

if (currentMember is IUnresolvedEvent) {

1250

wrapper.AddCustom("value");

1251

}

1252

1253

if (IsInSwitchContext(node)) {

1254

wrapper.AddCustom("case");

1255

}

1256

} else {

1257

if (((AstType)node).Parent is ParameterDeclaration) {

1258

AddKeywords(wrapper, parameterTypePredecessorKeywords);

1259

}

1260

}

1261

1262

AddKeywords(wrapper, primitiveTypesKeywords);

1263

if (currentMember != null) {

1264

wrapper.AddCustom("var");

1265

}

1266

wrapper.Result.AddRange(factory.CreateCodeTemplateCompletionData());

1267

1268

if (node != null && node.Role == Roles.Argument) {

1269

var resolved = ResolveExpression(node.Parent, unit);

1270

var invokeResult = resolved != null ? resolved.Item1 as CSharpInvocationResolveResult : null;

1271

if (invokeResult != null) {

1272

int argNum = 0;

1273

foreach (var arg in node.Parent.Children.Where (c => c.Role == Roles.Argument)) {

1274

if (arg == node) {

1275

break;

1276

}

1277

argNum++;

1278

}

1279

var param = argNum < invokeResult.Member.Parameters.Count ? invokeResult.Member.Parameters [argNum] : null;

1280

if (param != null && param.Type.Kind == TypeKind.Enum) {

1281

AddEnumMembers(wrapper, param.Type, state);

1282

}

1283

}

1284

}

1285

1286

if (node is Expression) {

1287

var astResolver = new CSharpAstResolver(state, unit, CSharpParsedFile);

1288

foreach (var type in CreateFieldAction.GetValidTypes(astResolver, (Expression)node)) {

1289

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

1290

AddEnumMembers(wrapper, type, state);

1291

} else if (type.Kind == TypeKind.Delegate) {

1292

AddDelegateHandlers(wrapper, type, true, true);

1293

AutoSelect = false;

1294

AutoCompleteEmptyMatch = false;

1295

}

1296

}

1297

}

1298

1299

// Add 'this' keyword for first parameter (extension method case)

1300

if (node != null && node.Parent is ParameterDeclaration &&

1301

node.Parent.PrevSibling != null && node.Parent.PrevSibling.Role == Roles.LPar) {

1302

wrapper.AddCustom("this");

1303

}

1304

}

1305

1306

static bool IsInSwitchContext(AstNode node)

1307

{

1308

var n = node;

1309

while (n != null && !(n is EntityDeclaration)) {

1310

if (n is SwitchStatement) {

1311

return true;

1312

}

1313

if (n is BlockStatement) {

1314

return false;

1315

}

1316

n = n.Parent;

1317

}

1318

return false;

1319

}

1320

1321

void AddTypesAndNamespaces(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node, Func<IType, IType> typePred = null, Predicate<IMember> memberPred = null, Action<ICompletionData, IType> callback = null)

1322

{

1323

var lookup = new MemberLookup(

1324

ctx.CurrentTypeDefinition,

1325

Compilation.MainAssembly

1326

);

1327

if (currentType != null) {

1328

for (var ct = currentType; ct != null; ct = ct.DeclaringTypeDefinition) {

1329

foreach (var nestedType in ct.NestedTypes) {

1330

string name = nestedType.Name;

1331

if (IsAttributeContext(node) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) {

1332

name = name.Substring(0, name.Length - "Attribute".Length);

1333

}

1334

1335

if (typePred == null) {

1336

wrapper.AddType(nestedType, name);

1337

continue;

1338

}

1339

1340

var type = typePred(nestedType.Resolve(ctx));

1341

if (type != null) {

1342

var a2 = wrapper.AddType(type, name);

1343

if (a2 != null && callback != null) {

1344

callback(a2, type);

1345

}

1346

}

1347

continue;

1348

}

1349

}

1350

if (this.currentMember != null && !(node is AstType)) {

1351

var def = ctx.CurrentTypeDefinition ?? Compilation.MainAssembly.GetTypeDefinition(currentType);

1352

if (def != null) {

1353

bool isProtectedAllowed = true;

1354

foreach (var member in def.GetMembers ()) {

1355

if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") {

1356

continue;

1357

}

1358

if (member.EntityType == EntityType.Operator) {

1359

continue;

1360

}

1361

if (member.IsExplicitInterfaceImplementation) {

1362

continue;

1363

}

1364

if (!lookup.IsAccessible(member, isProtectedAllowed)) {

1365

continue;

1366

}

1367

1368

if (memberPred == null || memberPred(member)) {

1369

wrapper.AddMember(member);

1370

}

1371

}

1372

var declaring = def.DeclaringTypeDefinition;

1373

while (declaring != null) {

1374

foreach (var member in declaring.GetMembers (m => m.IsStatic)) {

1375

if (memberPred == null || memberPred(member)) {

1376

wrapper.AddMember(member);

1377

}

1378

}

1379

declaring = declaring.DeclaringTypeDefinition;

1380

}

1381

}

1382

}

1383

foreach (var p in currentType.TypeParameters) {

1384

wrapper.AddTypeParameter(p);

1385

}

1386

}

1387

var scope = CSharpParsedFile.GetUsingScope(location).Resolve(Compilation);

1388

1389

for (var n = scope; n != null; n = n.Parent) {

1390

foreach (var pair in n.UsingAliases) {

1391

wrapper.AddNamespace(pair.Key);

1392

}

1393

foreach (var u in n.Usings) {

1394

foreach (var type in u.Types) {

1395

if (!lookup.IsAccessible(type, false))

1396

continue;

1397

1398

IType addType = typePred != null ? typePred(type) : type;

1399

if (addType != null) {

1400

string name = type.Name;

1401

if (IsAttributeContext(node) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) {

1402

name = name.Substring(0, name.Length - "Attribute".Length);

1403

}

1404

var a = wrapper.AddType(addType, name);

1405

if (a != null && callback != null) {

1406

callback(a, type);

1407

}

1408

}

1409

}

1410

}

1411

1412

foreach (var type in n.Namespace.Types) {

1413

if (!lookup.IsAccessible(type, false))

1414

continue;

1415

IType addType = typePred != null ? typePred(type) : type;

1416

if (addType != null) {

1417

var a2 = wrapper.AddType(addType, addType.Name);

1418

if (a2 != null && callback != null) {

1419

callback(a2, type);

1420

}

1421

}

1422

}

1423

1424

foreach (var curNs in n.Namespace.ChildNamespaces) {

1425

wrapper.AddNamespace(curNs.Name);

1426

}

1427

}

1428

}

1429

1430

IEnumerable<ICompletionData> HandleKeywordCompletion(int wordStart, string word)

1431

{

1432

if (IsInsideCommentStringOrDirective()) {

1433

if (IsInPreprocessorDirective()) {

1434

if (word == "if" || word == "elif") {

1435

if (wordStart > 0 && document.GetCharAt(wordStart - 1) == '#') {

1436

return factory.CreatePreProcessorDefinesCompletionData();

1437

}

1438

}

1439

}

1440

return null;

1441

}

1442

switch (word) {

1443

case "namespace":

1444

return null;

1445

case "using":

1446

if (currentType != null) {

1447

return null;

1448

}

1449

var wrapper = new CompletionDataWrapper(this);

1450

AddTypesAndNamespaces(wrapper, GetState(), null, t => null);

1451

return wrapper.Result;

1452

case "case":

1453

return CreateCaseCompletionData(location);

1454

// case ",":

1455

// case ":":

1456

// if (result.ExpressionContext == ExpressionContext.InheritableType) {

1457

// IType cls = NRefactoryResolver.GetTypeAtCursor (Document.CompilationUnit, Document.FileName, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset));

1458

// CompletionDataList completionList = new ProjectDomCompletionDataList ();

1459

// List<string > namespaceList = GetUsedNamespaces ();

1460

// var col = new CSharpTextEditorCompletion.CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, null, location);

1461

// bool isInterface = false;

1462

// HashSet<string > baseTypeNames = new HashSet<string> ();

1463

// if (cls != null) {

1464

// baseTypeNames.Add (cls.Name);

1465

// if (cls.ClassType == ClassType.Struct)

1466

// isInterface = true;

1467

// }

1468

// int tokenIndex = offset;

1469

1470

// // Search base types " : [Type1, ... ,TypeN,] <Caret>"

1471

// string token = null;

1472

// do {

1473

// token = GetPreviousToken (ref tokenIndex, false);

1474

// if (string.IsNullOrEmpty (token))

1475

// break;

1476

// token = token.Trim ();

1477

// if (Char.IsLetterOrDigit (token [0]) || token [0] == '_') {

1478

// IType baseType = dom.SearchType (Document.CompilationUnit, cls, result.Region.Start, token);

1479

// if (baseType != null) {

1480

// if (baseType.ClassType != ClassType.Interface)

1481

// isInterface = true;

1482

// baseTypeNames.Add (baseType.Name);

1483

// }

1484

// }

1485

// } while (token != ":");

1486

// foreach (object o in dom.GetNamespaceContents (namespaceList, true, true)) {

1487

// IType type = o as IType;

1488

// if (type != null && (type.IsStatic || type.IsSealed || baseTypeNames.Contains (type.Name) || isInterface && type.ClassType != ClassType.Interface)) {

1489

// continue;

1490

// }

1491

// if (o is Namespace && !namespaceList.Any (ns => ns.StartsWith (((Namespace)o).FullName)))

1492

// continue;

1493

// col.Add (o);

1494

// }

1495

// // Add inner classes

1496

// Stack<IType > innerStack = new Stack<IType> ();

1497

// innerStack.Push (cls);

1498

// while (innerStack.Count > 0) {

1499

// IType curType = innerStack.Pop ();

1500

// if (curType == null)

1501

// continue;

1502

// foreach (IType innerType in curType.InnerTypes) {

1503

// if (innerType != cls)

1504

// // don't add the calling class as possible base type

1505

// col.Add (innerType);

1506

// }

1507

// if (curType.DeclaringType != null)

1508

// innerStack.Push (curType.DeclaringType);

1509

// }

1510

// return completionList;

1511

// }

1512

// break;

1513

case "is":

1514

case "as":

1515

if (currentType == null) {

1516

return null;

1517

}

1518

IType isAsType = null;

1519

var isAsExpression = GetExpressionAt(wordStart);

1520

if (isAsExpression != null) {

1521

var parent = isAsExpression.Node.Parent;

1522

if (parent is VariableInitializer) {

1523

parent = parent.Parent;

1524

}

1525

if (parent is VariableDeclarationStatement) {

1526

var resolved = ResolveExpression(parent, isAsExpression.Unit);

1527

if (resolved != null) {

1528

isAsType = resolved.Item1.Type;

1529

}

1530

}

1531

}

1532

var isAsWrapper = new CompletionDataWrapper(this);

1533

var def = isAsType != null ? isAsType.GetDefinition() : null;

1534

AddTypesAndNamespaces(

1535

isAsWrapper,

1536

GetState(),

1537

null,

1538

t => t.GetDefinition() == null || def == null || t.GetDefinition().IsDerivedFrom(def) ? t : null,

1539

m => false);

1540

return isAsWrapper.Result;

1541

// {

1542

// CompletionDataList completionList = new ProjectDomCompletionDataList ();

1543

// ExpressionResult expressionResult = FindExpression (dom, completionContext, wordStart - document.Caret.Offset);

1544

// NRefactoryResolver resolver = CreateResolver ();

1545

// ResolveResult resolveResult = resolver.Resolve (expressionResult, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset));

1546

// if (resolveResult != null && resolveResult.ResolvedType != null) {

1547

// CompletionDataCollector col = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location);

1548

// IType foundType = null;

1549

// if (word == "as") {

1550

// ExpressionContext exactContext = new NewCSharpExpressionFinder (dom).FindExactContextForAsCompletion (document, Document.CompilationUnit, Document.FileName, resolver.CallingType);

1551

// if (exactContext is ExpressionContext.TypeExpressionContext) {

1552

// foundType = resolver.SearchType (((ExpressionContext.TypeExpressionContext)exactContext).Type);

1553

// AddAsCompletionData (col, foundType);

1554

// }

1555

// }

1556

1557

// if (foundType == null)

1558

// foundType = resolver.SearchType (resolveResult.ResolvedType);

1559

1560

// if (foundType != null) {

1561

// if (foundType.ClassType == ClassType.Interface)

1562

// foundType = resolver.SearchType (DomReturnType.Object);

1563

1564

// foreach (IType type in dom.GetSubclasses (foundType)) {

1565

// if (type.IsSpecialName || type.Name.StartsWith ("<"))

1566

// continue;

1567

// AddAsCompletionData (col, type);

1568

// }

1569

// }

1570

// List<string > namespaceList = GetUsedNamespaces ();

1571

// foreach (object o in dom.GetNamespaceContents (namespaceList, true, true)) {

1572

// if (o is IType) {

1573

// IType type = (IType)o;

1574

// if (type.ClassType != ClassType.Interface || type.IsSpecialName || type.Name.StartsWith ("<"))

1575

// continue;

1576

// // if (foundType != null && !dom.GetInheritanceTree (foundType).Any (x => x.FullName == type.FullName))

1577

// // continue;

1578

// AddAsCompletionData (col, type);

1579

// continue;

1580

// }

1581

// if (o is Namespace)

1582

// continue;

1583

// col.Add (o);

1584

// }

1585

// return completionList;

1586

// }

1587

// result.ExpressionContext = ExpressionContext.TypeName;

1588

// return CreateCtrlSpaceCompletionData (completionContext, result);

1589

// }

1590

case "override":

1591

// Look for modifiers, in order to find the beginning of the declaration

1592

int firstMod = wordStart;

1593

int i = wordStart;

1594

for (int n = 0; n < 3; n++) {

1595

string mod = GetPreviousToken(ref i, true);

1596

if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") {

1597

firstMod = i;

1598

} else if (mod == "static") {

1599

// static methods are not overridable

1600

return null;

1601

} else {

1602

break;

1603

}

1604

}

1605

if (!IsLineEmptyUpToEol()) {

1606

return null;

1607

}

1608

if (currentType != null && (currentType.Kind == TypeKind.Class || currentType.Kind == TypeKind.Struct)) {

1609

string modifiers = document.GetText(firstMod, wordStart - firstMod);

1610

return GetOverrideCompletionData(currentType, modifiers);

1611

}

1612

return null;

1613

case "partial":

1614

// Look for modifiers, in order to find the beginning of the declaration

1615

firstMod = wordStart;

1616

i = wordStart;

1617

for (int n = 0; n < 3; n++) {

1618

string mod = GetPreviousToken(ref i, true);

1619

if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") {

1620

firstMod = i;

1621

} else if (mod == "static") {

1622

// static methods are not overridable

1623

return null;

1624

} else {

1625

break;

1626

}

1627

}

1628

if (!IsLineEmptyUpToEol()) {

1629

return null;

1630

}

1631

var state = GetState();

1632

1633

if (state.CurrentTypeDefinition != null && (state.CurrentTypeDefinition.Kind == TypeKind.Class || state.CurrentTypeDefinition.Kind == TypeKind.Struct)) {

1634

string modifiers = document.GetText(firstMod, wordStart - firstMod);

1635

return GetPartialCompletionData(state.CurrentTypeDefinition, modifiers);

1636

}

1637

return null;

1638

1639

case "public":

1640

case "protected":

1641

case "private":

1642

case "internal":

1643

case "sealed":

1644

case "static":

1645

var accessorContext = HandleAccessorContext();

1646

if (accessorContext != null) {

1647

return accessorContext;

1648

}

1649

wrapper = new CompletionDataWrapper(this);

1650

state = GetState();

1651

if (currentType != null) {

1652

AddTypesAndNamespaces(wrapper, state, null, null, m => false);

1653

AddKeywords(wrapper, primitiveTypesKeywords);

1654

}

1655

AddKeywords(wrapper, typeLevelKeywords);

1656

return wrapper.Result;

1657

case "new":

1658

int j = offset - 4;

1659

// string token = GetPreviousToken (ref j, true);

1660

1661

IType hintType = null;

1662

var expressionOrVariableDeclaration = GetNewExpressionAt(j);

1663

if (expressionOrVariableDeclaration == null)

1664

return null;

1665

var astResolver = new CSharpAstResolver(

1666

GetState(),

1667

expressionOrVariableDeclaration.Unit,

1668

CSharpParsedFile

1669

);

1670

hintType = CreateFieldAction.GetValidTypes(

1671

astResolver,

1672

expressionOrVariableDeclaration.Node as Expression

1673

)

1674

.FirstOrDefault();

1675

1676

return CreateTypeCompletionData(hintType);

1677

case "yield":

1678

var yieldDataList = new CompletionDataWrapper(this);

1679

DefaultCompletionString = "return";

1680

yieldDataList.AddCustom("break");

1681

yieldDataList.AddCustom("return");

1682

return yieldDataList.Result;

1683

case "in":

1684

var inList = new CompletionDataWrapper(this);

1685

1686

var expr = GetExpressionAtCursor();

1687

var rr = ResolveExpression(expr);

1688

1689

AddContextCompletion(

1690

inList,

1691

rr != null ? rr.Item2 : GetState(),

1692

expr.Node,

1693

Unit

1694

);

1695

return inList.Result;

1696

}

1697

return null;

1698

}

1699

1700

bool IsLineEmptyUpToEol()

1701

{

1702

var line = document.GetLineByNumber(location.Line);

1703

for (int j = offset; j < line.EndOffset; j++) {

1704

char ch = document.GetCharAt(j);

1705

if (!char.IsWhiteSpace(ch)) {

1706

return false;

1707

}

1708

}

1709

return true;

1710

}

1711

1712

string GetLineIndent(int lineNr)

1713

{

1714

var line = document.GetLineByNumber(lineNr);

1715

for (int j = line.Offset; j < line.EndOffset; j++) {

1716

char ch = document.GetCharAt(j);

1717

if (!char.IsWhiteSpace(ch)) {

1718

return document.GetText(line.Offset, j - line.Offset - 1);

1719

}

1720

}

1721

return "";

1722

}

1723

1724

static CSharpAmbience amb = new CSharpAmbience();

1725

1726

class Category : CompletionCategory

1727

{

1728

public Category(string displayText, string icon) : base (displayText, icon)

1729

{

1730

}

1731

1732

public override int CompareTo(CompletionCategory other)

1733

{

1734

return 0;

1735

}

1736

}

1737

1738

IEnumerable<ICompletionData> CreateTypeCompletionData(IType hintType)

1739

{

1740

var wrapper = new CompletionDataWrapper(this);

1741

var state = GetState();

1742

Func<IType, IType> pred = null;

1743

Action<ICompletionData, IType> typeCallback = null;

1744

var inferredTypesCategory = new Category("Inferred Types", null);

1745

var derivedTypesCategory = new Category("Derived Types", null);

1746

1747

if (hintType != null) {

1748

if (hintType.Kind != TypeKind.Unknown) {

1749

var lookup = new MemberLookup(

1750

ctx.CurrentTypeDefinition,

1751

Compilation.MainAssembly

1752

);

1753

typeCallback = (data, t) => {

1754

//check if type is in inheritance tree.

1755

if (hintType.GetDefinition() != null &&

1756

t.GetDefinition() != null &&

1757

t.GetDefinition().IsDerivedFrom(hintType.GetDefinition())) {

1758

data.CompletionCategory = derivedTypesCategory;

1759

}

1760

};

1761

pred = t => {

1762

if (t.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array) {

1763

return null;

1764

}

1765

// check for valid constructors

1766

if (t.GetConstructors().Count() > 0) {

1767

bool isProtectedAllowed = currentType != null ?

1768

currentType.Resolve(ctx).GetDefinition().IsDerivedFrom(t.GetDefinition()) :

1769

false;

1770

if (!t.GetConstructors().Any(m => lookup.IsAccessible(

1771

1772

isProtectedAllowed

1773

)

1774

)) {

1775

return null;

1776

}

1777

}

1778

1779

var typeInference = new TypeInference(Compilation);

1780

typeInference.Algorithm = TypeInferenceAlgorithm.ImprovedReturnAllResults;

1781

var inferedType = typeInference.FindTypeInBounds(

1782

new [] { t },

1783

new [] { hintType }

1784

);

1785

if (inferedType != SpecialType.UnknownType) {

1786

var newType = wrapper.AddType(inferedType, amb.ConvertType(inferedType));

1787

if (newType != null) {

1788

newType.CompletionCategory = inferredTypesCategory;

1789

}

1790

return null;

1791

}

1792

return t;

1793

};

1794

if (!(hintType.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array)) {

1795

DefaultCompletionString = GetShortType(hintType, GetState());

1796

var hint = wrapper.AddType(hintType, DefaultCompletionString);

1797

if (hint != null) {

1798

hint.CompletionCategory = derivedTypesCategory;

1799

}

1800

}

1801

if (hintType is ParameterizedType && hintType.TypeParameterCount == 1 && hintType.FullName == "System.Collections.Generic.IEnumerable") {

1802

var arg = ((ParameterizedType)hintType).TypeArguments.FirstOrDefault();

1803

var array = new ArrayTypeReference(arg.ToTypeReference(), 1).Resolve(ctx);

1804

wrapper.AddType(array, amb.ConvertType(array));

1805

}

1806

} else {

1807

var hint = wrapper.AddType(hintType, DefaultCompletionString);

1808

if (hint != null) {

1809

DefaultCompletionString = hint.DisplayText;

1810

hint.CompletionCategory = derivedTypesCategory;

1811

}

1812

}

1813

}

1814

AddTypesAndNamespaces(wrapper, state, null, pred, m => false, typeCallback);

1815

if (hintType == null || hintType == SpecialType.UnknownType) {

1816

AddKeywords(wrapper, primitiveTypesKeywords.Where(k => k != "void"));

1817

}

1818

1819

CloseOnSquareBrackets = true;

1820

AutoCompleteEmptyMatch = true;

1821

return wrapper.Result;

1822

}

1823

1824

IEnumerable<ICompletionData> GetOverrideCompletionData(IUnresolvedTypeDefinition type, string modifiers)

1825

{

1826

var wrapper = new CompletionDataWrapper(this);

1827

var alreadyInserted = new List<IMember>();

1828

//bool addedVirtuals = false;

1829

1830

int declarationBegin = offset;

1831

int j = declarationBegin;

1832

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

1833

switch (GetPreviousToken(ref j, true)) {

1834

case "public":

1835

case "protected":

1836

case "private":

1837

case "internal":

1838

case "sealed":

1839

case "override":

1840

declarationBegin = j;

1841

break;

1842

case "static":

1843

return null; // don't add override completion for static members

1844

}

1845

}

1846

AddVirtuals(

1847

alreadyInserted,

1848

wrapper,

1849

modifiers,

1850

type.Resolve(ctx),

1851

declarationBegin

1852

);

1853

return wrapper.Result;

1854

}

1855

1856

IEnumerable<ICompletionData> GetPartialCompletionData(ITypeDefinition type, string modifiers)

1857

{

1858

var wrapper = new CompletionDataWrapper(this);

1859

int declarationBegin = offset;

1860

int j = declarationBegin;

1861

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

1862

switch (GetPreviousToken(ref j, true)) {

1863

case "public":

1864

case "protected":

1865

case "private":

1866

case "internal":

1867

case "sealed":

1868

case "override":

1869

declarationBegin = j;

1870

break;

1871

case "static":

1872

return null; // don't add override completion for static members

1873

}

1874

}

1875

1876

var methods = new List<IUnresolvedMethod>();

1877

1878

foreach (var part in type.Parts) {

1879

foreach (var method in part.Methods) {

1880

if (method.BodyRegion.IsEmpty) {

1881

if (GetImplementation(type, method) != null) {

1882

continue;

1883

}

1884

methods.Add(method);

1885

}

1886

}

1887

}

1888

1889

foreach (var method in methods) {

1890

wrapper.Add(factory.CreateNewPartialCompletionData(

1891

declarationBegin,

1892

method.DeclaringTypeDefinition,

1893

method

1894

)

1895

);

1896

}

1897

1898

return wrapper.Result;

1899

}

1900

1901

IMethod GetImplementation(ITypeDefinition type, IUnresolvedMethod method)

1902

{

1903

foreach (var cur in type.Methods) {

1904

if (cur.Name == method.Name && cur.Parameters.Count == method.Parameters.Count && !cur.BodyRegion.IsEmpty) {

1905

bool equal = true;

1906

/*for (int i = 0; i < cur.Parameters.Count; i++) {

1907

if (!cur.Parameters [i].Type.Equals (method.Parameters [i].Type)) {

1908

equal = false;

1909

break;

1910

}

1911

}*/

1912

if (equal) {

1913

return cur;

1914

}

1915

}

1916

}

1917

return null;

1918

}

1919

1920

void AddVirtuals(List<IMember> alreadyInserted, CompletionDataWrapper col, string modifiers, IType curType, int declarationBegin)

1921

{

1922

if (curType == null) {

1923

return;

1924

}

1925

foreach (var m in curType.GetMembers ().Reverse ()) {

1926

if (m.IsSynthetic || curType.Kind != TypeKind.Interface && !m.IsOverridable) {

1927

continue;

1928

}

1929

// filter out the "Finalize" methods, because finalizers should be done with destructors.

1930

if (m is IMethod && m.Name == "Finalize") {

1931

continue;

1932

}

1933

1934

var data = factory.CreateNewOverrideCompletionData(

1935

declarationBegin,

1936

currentType,

1937

1938

);

1939

// check if the member is already implemented

1940

bool foundMember = curType.GetMembers().Any(cm => SignatureComparer.Ordinal.Equals(

1941

cm,

1942

1943

) && cm.DeclaringTypeDefinition == curType.GetDefinition()

1944

);

1945

if (foundMember) {

1946

continue;

1947

}

1948

if (alreadyInserted.Any(cm => SignatureComparer.Ordinal.Equals(cm, m)))

1949

continue;

1950

alreadyInserted.Add(m);

1951

data.CompletionCategory = col.GetCompletionCategory(m.DeclaringTypeDefinition);

1952

col.Add(data);

1953

}

1954

}

1955

1956

static void AddKeywords(CompletionDataWrapper wrapper, IEnumerable<string> keywords)

1957

{

1958

foreach (string keyword in keywords) {

1959

if (wrapper.Result.Any(data => data.DisplayText == keyword))

1960

continue;

1961

wrapper.AddCustom(keyword);

1962

}

1963

}

1964

1965

public string GetPreviousMemberReferenceExpression(int tokenIndex)

1966

{

1967

string result = GetPreviousToken(ref tokenIndex, false);

1968

result = GetPreviousToken(ref tokenIndex, false);

1969

if (result != ".") {

1970

result = null;

1971

} else {

1972

var names = new List<string>();

1973

while (result == ".") {

1974

result = GetPreviousToken(ref tokenIndex, false);

1975

if (result == "this") {

1976

names.Add("handle");

1977

} else if (result != null) {

1978

string trimmedName = result.Trim();

1979

if (trimmedName.Length == 0) {

1980

break;

1981

}

1982

names.Insert(0, trimmedName);

1983

}

1984

result = GetPreviousToken(ref tokenIndex, false);

1985

}

1986

result = String.Join("", names.ToArray());

1987

foreach (char ch in result) {

1988

if (!char.IsLetterOrDigit(ch) && ch != '_') {

1989

result = "";

1990

break;

1991

}

1992

}

1993

}

1994

return result;

1995

}

1996

1997

bool MatchDelegate(IType delegateType, IUnresolvedMethod method)

1998

{

1999

var delegateMethod = delegateType.GetDelegateInvokeMethod();

2000

if (delegateMethod == null || delegateMethod.Parameters.Count != method.Parameters.Count) {

2001

return false;

2002

}

2003

2004

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

2005

if (!delegateMethod.Parameters [i].Type.Equals(method.Parameters [i].Type.Resolve(ctx))) {

2006

return false;

2007

}

2008

}

2009

return true;

2010

}

2011

2012

string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true)

2013

{

2014

IMethod delegateMethod = delegateType.GetDelegateInvokeMethod();

2015

var thisLineIndent = GetLineIndent(location.Line);

2016

string delegateEndString = EolMarker + thisLineIndent + "}" + (addSemicolon ? ";" : "");

2017

//bool containsDelegateData = completionList.Result.Any(d => d.DisplayText.StartsWith("delegate("));

2018

if (addDefault) {

2019

var oldDelegate = completionList.Result.FirstOrDefault(cd => cd.DisplayText == "delegate");

2020

if (oldDelegate != null)

2021

completionList.Result.Remove(oldDelegate);

2022

completionList.AddCustom(

2023

"delegate",

2024

"Creates anonymous delegate.",

2025

"delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString

2026

);

2027

}

2028

var sb = new StringBuilder("(");

2029

var sbWithoutTypes = new StringBuilder("(");

2030

for (int k = 0; k < delegateMethod.Parameters.Count; k++) {

2031

if (k > 0) {

2032

sb.Append(", ");

2033

sbWithoutTypes.Append(", ");

2034

}

2035

var parameterType = delegateMethod.Parameters [k].Type;

2036

sb.Append(GetShortType(parameterType, GetState()));

2037

sb.Append(" ");

2038

sb.Append(delegateMethod.Parameters [k].Name);

2039

sbWithoutTypes.Append(delegateMethod.Parameters [k].Name);

2040

}

2041

sb.Append(")");

2042

sbWithoutTypes.Append(")");

2043

completionList.AddCustom(

2044

"delegate" + sb,

2045

"Creates anonymous delegate.",

2046

"delegate" + sb + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString

2047

);

2048

if (!completionList.Result.Any(data => data.DisplayText == sbWithoutTypes.ToString())) {

2049

completionList.AddCustom(

2050

sbWithoutTypes.ToString(),

2051

"Creates lambda expression.",

2052

sbWithoutTypes + " => |" + (addSemicolon ? ";" : "")

2053

);

2054

}

2055

/* TODO:Make factory method out of it.

2056

// It's needed to temporarly disable inserting auto matching bracket because the anonymous delegates are selectable with '('

2057

// otherwise we would end up with () => )

2058

if (!containsDelegateData) {

2059

var savedValue = MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket;

2060

MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = false;

2061

completionList.Result.CompletionListClosed += delegate {

2062

MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = savedValue;

2063

};

2064

}*/

2065

return sb.ToString();

2066

}

2067

2068

bool IsAccessibleFrom(IEntity member, ITypeDefinition calledType, IMember currentMember, bool includeProtected)

2069

{

2070

if (currentMember == null) {

2071

return member.IsStatic || member.IsPublic;

2072

}

2073

// if (currentMember is MonoDevelop.Projects.Dom.BaseResolveResult.BaseMemberDecorator)

2074

// return member.IsPublic | member.IsProtected;

2075

// if (member.IsStatic && !IsStatic)

2076

// return false;

2077

if (member.IsPublic || calledType != null && calledType.Kind == TypeKind.Interface && !member.IsProtected) {

2078

return true;

2079

}

2080

if (member.DeclaringTypeDefinition != null) {

2081

if (member.DeclaringTypeDefinition.Kind == TypeKind.Interface) {

2082

return IsAccessibleFrom(

2083

member.DeclaringTypeDefinition,

2084

calledType,

2085

currentMember,

2086

includeProtected

2087

);

2088

}

2089

2090

if (member.IsProtected && !(member.DeclaringTypeDefinition.IsProtectedOrInternal && !includeProtected)) {

2091

return includeProtected;

2092

}

2093

}

2094

if (member.IsInternal || member.IsProtectedAndInternal || member.IsProtectedOrInternal) {

2095

//var type1 = member is ITypeDefinition ? (ITypeDefinition)member : member.DeclaringTypeDefinition;

2096

//var type2 = currentMember is ITypeDefinition ? (ITypeDefinition)currentMember : currentMember.DeclaringTypeDefinition;

2097

bool result = true;

2098

// easy case, projects are the same

2099

/*// if (type1.ProjectContent == type2.ProjectContent) {

2100

// result = true;

2101

// } else

2102

if (type1.ProjectContent != null) {

2103

// maybe type2 hasn't project dom set (may occur in some cases), check if the file is in the project

2104

//TODO !!

2105

// result = type1.ProjectContent.Annotation<MonoDevelop.Projects.Project> ().GetProjectFile (type2.Region.FileName) != null;

2106

result = false;

2107

} else if (type2.ProjectContent != null) {

2108

//TODO!!

2109

// result = type2.ProjectContent.Annotation<MonoDevelop.Projects.Project> ().GetProjectFile (type1.Region.FileName) != null;

2110

result = false;

2111

} else {

2112

// should never happen !

2113

result = true;

2114

}*/

2115

return member.IsProtectedAndInternal ? includeProtected && result : result;

2116

}

2117

2118

if (!(currentMember is IType) && (currentMember.DeclaringTypeDefinition == null || member.DeclaringTypeDefinition == null)) {

2119

return false;

2120

}

2121

2122

// inner class

2123

var declaringType = currentMember.DeclaringTypeDefinition;

2124

while (declaringType != null) {

2125

if (declaringType.ReflectionName == currentMember.DeclaringType.ReflectionName) {

2126

return true;

2127

}

2128

declaringType = declaringType.DeclaringTypeDefinition;

2129

}

2130

2131

2132

return currentMember.DeclaringTypeDefinition != null && member.DeclaringTypeDefinition.FullName == currentMember.DeclaringTypeDefinition.FullName;

2133

}

2134

2135

static bool IsAttributeContext(AstNode node)

2136

{

2137

AstNode n = node;

2138

while (n is AstType) {

2139

n = n.Parent;

2140

}

2141

return n is Attribute;

2142

}

2143

2144

IEnumerable<ICompletionData> CreateTypeAndNamespaceCompletionData(TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CSharpResolver state)

2145

{

2146

if (resolveResult == null || resolveResult.IsError) {

2147

return null;

2148

}

2149

var exprParent = resolvedNode.GetParent<Expression>();

2150

var unit = exprParent != null ? exprParent.GetParent<CompilationUnit>() : null;

2151

2152

var astResolver = unit != null ? new CSharpAstResolver(

2153

state,

2154

unit,

2155

CSharpParsedFile

2156

) : null;

2157

IType hintType = exprParent != null && astResolver != null ?

2158

CreateFieldAction.GetValidTypes(astResolver, exprParent) .FirstOrDefault() :

2159

null;

2160

var result = new CompletionDataWrapper(this);

2161

if (resolveResult is NamespaceResolveResult) {

2162

var nr = (NamespaceResolveResult)resolveResult;

2163

if (!(resolvedNode.Parent is UsingDeclaration || resolvedNode.Parent != null && resolvedNode.Parent.Parent is UsingDeclaration)) {

2164

foreach (var cl in nr.Namespace.Types) {

2165

string name = cl.Name;

2166

if (hintType != null && hintType.Kind != TypeKind.Array && cl.Kind == TypeKind.Interface) {

2167

continue;

2168

}

2169

if (IsAttributeContext(resolvedNode) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) {

2170

name = name.Substring(0, name.Length - "Attribute".Length);

2171

}

2172

result.AddType(cl, name);

2173

}

2174

}

2175

foreach (var ns in nr.Namespace.ChildNamespaces) {

2176

result.AddNamespace(ns.Name);

2177

}

2178

} else if (resolveResult is TypeResolveResult) {

2179

var type = resolveResult.Type;

2180

foreach (var nested in type.GetNestedTypes ()) {

2181

if (hintType != null && hintType.Kind != TypeKind.Array && nested.Kind == TypeKind.Interface) {

2182

continue;

2183

}

2184

result.AddType(nested, nested.Name);

2185

}

2186

}

2187

return result.Result;

2188

}

2189

2190

IEnumerable<ICompletionData> CreateTypeList()

2191

{

2192

foreach (var cl in Compilation.RootNamespace.Types) {

2193

yield return factory.CreateTypeCompletionData(cl, cl.Name);

2194

}

2195

2196

foreach (var ns in Compilation.RootNamespace.ChildNamespaces) {

2197

yield return factory.CreateNamespaceCompletionData(ns.Name);

2198

}

2199

}

2200

2201

IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, CompilationUnit unit, int parameter, bool controlSpace)

2202

{

2203

var result = new CompletionDataWrapper(this);

2204

var addedEnums = new HashSet<string>();

2205

var addedDelegates = new HashSet<string>();

2206

2207

foreach (var method in resolveResult.Methods) {

2208

if (method.Parameters.Count <= parameter) {

2209

continue;

2210

}

2211

var resolvedType = method.Parameters [parameter].Type;

2212

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

2213

if (addedEnums.Contains(resolvedType.ReflectionName)) {

2214

continue;

2215

}

2216

addedEnums.Add(resolvedType.ReflectionName);

2217

AddEnumMembers(result, resolvedType, state);

2218

} else if (resolvedType.Kind == TypeKind.Delegate) {

2219

if (addedDelegates.Contains(resolvedType.ReflectionName))

2220

continue;

2221

string parameterDefinition = AddDelegateHandlers(result, resolvedType);

2222

string varName = "Handle" + method.Parameters [parameter].Type.Name + method.Parameters [parameter].Name;

2223

result.Result.Add(

2224

factory.CreateEventCreationCompletionData(

2225

varName,

2226

resolvedType,

2227

null,

2228

parameterDefinition,

2229

currentMember,

2230

currentType)

2231

);

2232

}

2233

}

2234

if (!controlSpace) {

2235

if (addedEnums.Count + addedDelegates.Count == 0) {

2236

return Enumerable.Empty<ICompletionData>();

2237

}

2238

AutoCompleteEmptyMatch = false;

2239

AutoSelect = false;

2240

}

2241

AddContextCompletion(result, state, invocation, unit);

2242

2243

// resolver.AddAccessibleCodeCompletionData (ExpressionContext.MethodBody, cdc);

2244

// if (addedDelegates.Count > 0) {

2245

// foreach (var data in result.Result) {

2246

// if (data is MemberCompletionData)

2247

// ((MemberCompletionData)data).IsDelegateExpected = true;

2248

// }

2249

// }

2250

return result.Result;

2251

}

2252

2253

string GetShortType(IType type, CSharpResolver state)

2254

{

2255

var builder = new TypeSystemAstBuilder(state);

2256

var dt = state.CurrentTypeDefinition;

2257

var declaring = type.DeclaringType != null ? type.DeclaringType.GetDefinition() : null;

2258

if (declaring != null) {

2259

while (dt != null) {

2260

if (dt.Equals(declaring)) {

2261

builder.AlwaysUseShortTypeNames = true;

2262

break;

2263

}

2264

dt = dt.DeclaringTypeDefinition;

2265

}

2266

}

2267

var shortType = builder.ConvertType(type);

2268

return shortType.GetText(FormattingPolicy);

2269

}

2270

2271

void AddEnumMembers(CompletionDataWrapper completionList, IType resolvedType, CSharpResolver state)

2272

{

2273

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

2274

return;

2275

}

2276

string typeString = GetShortType(resolvedType, state);

2277

if (typeString.Contains(".")) {

2278

completionList.AddType(resolvedType, typeString);

2279

}

2280

foreach (var field in resolvedType.GetFields ()) {

2281

if (field.IsConst || field.IsStatic) {

2282

completionList.Result.Add(factory.CreateEntityCompletionData(

2283

field,

2284

typeString + "." + field.Name

2285

)

2286

);

2287

}

2288

}

2289

DefaultCompletionString = typeString;

2290

}

2291

2292

IEnumerable<ICompletionData> CreateCompletionData(TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CSharpResolver state, Func<IType, IType> typePred = null)

2293

{

2294

if (resolveResult == null /*|| resolveResult.IsError*/) {

2295

return null;

2296

}

2297

2298

if (resolveResult is NamespaceResolveResult) {

2299

var nr = (NamespaceResolveResult)resolveResult;

2300

var namespaceContents = new CompletionDataWrapper(this);

2301

2302

foreach (var cl in nr.Namespace.Types) {

2303

IType addType = typePred != null ? typePred(cl) : cl;

2304

if (addType != null)

2305

namespaceContents.AddType(addType, addType.Name);

2306

}

2307

2308

foreach (var ns in nr.Namespace.ChildNamespaces) {

2309

namespaceContents.AddNamespace(ns.Name);

2310

}

2311

return namespaceContents.Result;

2312

}

2313

2314

IType type = resolveResult.Type;

2315

//var typeDef = resolveResult.Type.GetDefinition();

2316

var result = new CompletionDataWrapper(this);

2317

bool includeStaticMembers = false;

2318

2319

var lookup = new MemberLookup(

2320

ctx.CurrentTypeDefinition,

2321

Compilation.MainAssembly

2322

);

2323

2324

2325

if (resolveResult is LocalResolveResult) {

2326

if (resolvedNode is IdentifierExpression) {

2327

var mrr = (LocalResolveResult)resolveResult;

2328

includeStaticMembers = mrr.Variable.Name == mrr.Type.Name;

2329

}

2330

}

2331

if (resolveResult is TypeResolveResult && type.Kind == TypeKind.Enum) {

2332

foreach (var field in type.GetFields ()) {

2333

if (!lookup.IsAccessible(field, false))

2334

continue;

2335

result.AddMember(field);

2336

}

2337

foreach (var m in type.GetMethods ()) {

2338

if (m.Name == "TryParse") {

2339

result.AddMember(m);

2340

}

2341

}

2342

return result.Result;

2343

}

2344

2345

bool isProtectedAllowed = resolveResult is ThisResolveResult ? true : lookup.IsProtectedAccessAllowed(type);

2346

bool skipNonStaticMembers = (resolveResult is TypeResolveResult);

2347

2348

if (resolveResult is MemberResolveResult && resolvedNode is IdentifierExpression) {

2349

var mrr = (MemberResolveResult)resolveResult;

2350

includeStaticMembers = mrr.Member.Name == mrr.Type.Name;

2351

2352

TypeResolveResult trr;

2353

if (state.IsVariableReferenceWithSameType(

2354

resolveResult,

2355

((IdentifierExpression)resolvedNode).Identifier,

2356

out trr

2357

)) {

2358

if (currentMember != null && mrr.Member.IsStatic ^ currentMember.IsStatic) {

2359

skipNonStaticMembers = true;

2360

2361

if (trr.Type.Kind == TypeKind.Enum) {

2362

foreach (var field in trr.Type.GetFields ()) {

2363

result.AddMember(field);

2364

}

2365

foreach (var m in trr.Type.GetMethods ()) {

2366

if (m.Name == "TryParse" && m.IsStatic) {

2367

result.AddMember(m);

2368

}

2369

}

2370

return result.Result;

2371

}

2372

}

2373

}

2374

// ADD Aliases

2375

var scope = CSharpParsedFile.GetUsingScope(location).Resolve(Compilation);

2376

2377

for (var n = scope; n != null; n = n.Parent) {

2378

foreach (var pair in n.UsingAliases) {

2379

if (pair.Key == mrr.Member.Name) {

2380

foreach (var r in CreateCompletionData (location, pair.Value, resolvedNode, state)) {

2381

if (r is IEntityCompletionData && ((IEntityCompletionData)r).Entity is IMember) {

2382

result.AddMember((IMember)((IEntityCompletionData)r).Entity);

2383

} else {

2384

result.Add(r);

2385

}

2386

}

2387

}

2388

}

2389

}

2390

2391

2392

}

2393

if (resolveResult is TypeResolveResult && (resolvedNode is IdentifierExpression || resolvedNode is MemberReferenceExpression)) {

2394

includeStaticMembers = true;

2395

}

2396

2397

// Console.WriteLine ("type:" + type +"/"+type.GetType ());

2398

// Console.WriteLine ("current:" + ctx.CurrentTypeDefinition);

2399

// Console.WriteLine ("IS PROT ALLOWED:" + isProtectedAllowed + " static: "+ includeStaticMembers);

2400

// Console.WriteLine (resolveResult);

2401

// Console.WriteLine ("node:" + resolvedNode);

2402

// Console.WriteLine (currentMember != null ? currentMember.IsStatic : "currentMember == null");

2403

2404

if (resolvedNode.Annotation<ObjectCreateExpression>() == null) {

2405

//tags the created expression as part of an object create expression.

2406

2407

var filteredList = new List<IMember>();

2408

foreach (var member in type.GetMembers ()) {

2409

if (member.EntityType == EntityType.Indexer || member.EntityType == EntityType.Operator || member.EntityType == EntityType.Constructor || member.EntityType == EntityType.Destructor) {

2410

continue;

2411

}

2412

if (member.IsExplicitInterfaceImplementation) {

2413

continue;

2414

}

2415

// Console.WriteLine ("member:" + member + member.IsShadowing);

2416

if (!lookup.IsAccessible(member, isProtectedAllowed)) {

2417

// Console.WriteLine ("skip access: " + member.FullName);

2418

continue;

2419

}

2420

if (resolvedNode is BaseReferenceExpression && member.IsAbstract) {

2421

continue;

2422

}

2423

bool memberIsStatic = member.IsStatic;

2424

if (!includeStaticMembers && memberIsStatic && !(resolveResult is TypeResolveResult)) {

2425

// Console.WriteLine ("skip static member: " + member.FullName);

2426

continue;

2427

}

2428

var field = member as IField;

2429

if (field != null) {

2430

memberIsStatic |= field.IsConst;

2431

}

2432

2433

if (!memberIsStatic && skipNonStaticMembers) {

2434

continue;

2435

}

2436

2437

if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") {

2438

continue;

2439

}

2440

if (member.EntityType == EntityType.Operator) {

2441

continue;

2442

}

2443

if (member.IsExplicitInterfaceImplementation) {

2444

continue;

2445

}

2446

if (member.IsShadowing) {

2447

filteredList.RemoveAll(m => m.Name == member.Name);

2448

}

2449

filteredList.Add(member);

2450

}

2451

2452

foreach (var member in filteredList) {

2453

// Console.WriteLine ("add:" + member + "/" + member.IsStatic);

2454

result.AddMember(member);

2455

}

2456

}

2457

2458

if (resolveResult is TypeResolveResult || includeStaticMembers) {

2459

foreach (var nested in type.GetNestedTypes ()) {

2460

IType addType = typePred != null ? typePred(nested) : nested;

2461

if (addType != null)

2462

result.AddType(addType, addType.Name);

2463

}

2464

2465

} else {

2466

foreach (var meths in state.GetExtensionMethods (type)) {

2467

foreach (var m in meths) {

2468

result.AddMember(m);

2469

}

2470

}

2471

}

2472

2473

// IEnumerable<object> objects = resolveResult.CreateResolveResult (dom, resolver != null ? resolver.CallingMember : null);

2474

// CompletionDataCollector col = new CompletionDataCollector (this, dom, result, Document.CompilationUnit, resolver != null ? resolver.CallingType : null, location);

2475

// col.HideExtensionParameter = !resolveResult.StaticResolve;

2476

// col.NamePrefix = expressionResult.Expression;

2477

// bool showOnlyTypes = expressionResult.Contexts.Any (ctx => ctx == ExpressionContext.InheritableType || ctx == ExpressionContext.Constraints);

2478

// if (objects != null) {

2479

// foreach (object obj in objects) {

2480

// if (expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.FilterEntry (obj))

2481

// continue;

2482

// if (expressionResult.ExpressionContext == ExpressionContext.NamespaceNameExcepted && !(obj is Namespace))

2483

// continue;

2484

// if (showOnlyTypes && !(obj is IType))

2485

// continue;

2486

// CompletionData data = col.Add (obj);

2487

// if (data != null && expressionResult.ExpressionContext == ExpressionContext.Attribute && data.CompletionText != null && data.CompletionText.EndsWith ("Attribute")) {

2488

// string newText = data.CompletionText.Substring (0, data.CompletionText.Length - "Attribute".Length);

2489

// data.SetText (newText);

2490

// }

2491

// }

2492

// }

2493

2494

return result.Result;

2495

}

2496

2497

IEnumerable<ICompletionData> CreateCaseCompletionData(TextLocation location)

2498

{

2499

var unit = ParseStub("a: break;");

2500

if (unit == null) {

2501

return null;

2502

}

2503

var s = unit.GetNodeAt<SwitchStatement>(location);

2504

if (s == null) {

2505

return null;

2506

}

2507

2508

var offset = document.GetOffset(s.Expression.StartLocation);

2509

var expr = GetExpressionAt(offset);

2510

if (expr == null) {

2511

return null;

2512

}

2513

2514

var resolveResult = ResolveExpression(expr);

2515

if (resolveResult == null || resolveResult.Item1.Type.Kind != TypeKind.Enum) {

2516

return null;

2517

}

2518

var wrapper = new CompletionDataWrapper(this);

2519

AddEnumMembers(wrapper, resolveResult.Item1.Type, resolveResult.Item2);

2520

AutoCompleteEmptyMatch = false;

2521

return wrapper.Result;

2522

}

2523

2524

#region Parsing methods

2525

ExpressionResult GetExpressionBeforeCursor()

2526

{

2527

CompilationUnit baseUnit;

2528

if (currentMember == null) {

2529

baseUnit = ParseStub("a", false);

2530

var type = baseUnit.GetNodeAt<MemberType>(location);

2531

if (type == null) {

2532

baseUnit = ParseStub("a;", false);

2533

type = baseUnit.GetNodeAt<MemberType>(location);

2534

}

2535

2536

if (type == null) {

2537

baseUnit = ParseStub("A a;", false);

2538

type = baseUnit.GetNodeAt<MemberType>(location);

2539

}

2540

if (type != null) {

2541

return new ExpressionResult((AstNode)type.Target, baseUnit);

2542

}

2543

}

2544

2545

baseUnit = ParseStub("a", false);

2546

var curNode = baseUnit.GetNodeAt(location);

2547

2548

// hack for local variable declaration missing ';' issue - remove that if it works.

2549

if (curNode is EntityDeclaration || baseUnit.GetNodeAt<Expression>(location) == null && baseUnit.GetNodeAt<MemberType>(location) == null) {

2550

baseUnit = ParseStub("a");

2551

curNode = baseUnit.GetNodeAt(location);

2552

}

2553

2554

// Hack for handle object initializer continuation expressions

2555

if (curNode is EntityDeclaration || baseUnit.GetNodeAt<Expression>(location) == null && baseUnit.GetNodeAt<MemberType>(location) == null) {

2556

baseUnit = ParseStub("a};");

2557

}

2558

var mref = baseUnit.GetNodeAt<MemberReferenceExpression>(location);

2559

if (currentMember == null && currentType == null) {

2560

if (mref != null) {

2561

return new ExpressionResult((AstNode)mref.Target, baseUnit);

2562

}

2563

return null;

2564

}

2565

2566

//var memberLocation = currentMember != null ? currentMember.Region.Begin : currentType.Region.Begin;

2567

if (mref == null) {

2568

var type = baseUnit.GetNodeAt<MemberType>(location);

2569

if (type != null) {

2570

return new ExpressionResult((AstNode)type.Target, baseUnit);

2571

}

2572

}

2573

AstNode expr = null;

2574

if (mref != null) {

2575

expr = mref.Target;

2576

} else {

2577

Expression tref = baseUnit.GetNodeAt<TypeReferenceExpression>(location);

2578

MemberType memberType = tref != null ? ((TypeReferenceExpression)tref).Type as MemberType : null;

2579

if (memberType == null) {

2580

memberType = baseUnit.GetNodeAt<MemberType>(location);

2581

if (memberType != null) {

2582

if (memberType.Parent is ObjectCreateExpression) {

2583

var mt = memberType.Target.Clone();

2584

memberType.ReplaceWith(mt);

2585

expr = mt;

2586

goto exit;

2587

} else {

2588

tref = baseUnit.GetNodeAt<Expression>(location);

2589

if (tref == null) {

2590

tref = new TypeReferenceExpression(memberType.Clone());

2591

memberType.Parent.AddChild(tref, Roles.Expression);

2592

}

2593

if (tref is ObjectCreateExpression) {

2594

expr = new TypeReferenceExpression(memberType.Target.Clone());

2595

expr.AddAnnotation(new ObjectCreateExpression());

2596

}

2597

}

2598

}

2599

}

2600

2601

if (memberType == null) {

2602

return null;

2603

}

2604

if (expr == null) {

2605

expr = new TypeReferenceExpression(memberType.Target.Clone());

2606

}

2607

tref.ReplaceWith(expr);

2608

}

2609

exit:

2610

return new ExpressionResult((AstNode)expr, baseUnit);

2611

}

2612

2613

ExpressionResult GetExpressionAtCursor()

2614

{

2615

// TextLocation memberLocation;

2616

// if (currentMember != null) {

2617

// memberLocation = currentMember.Region.Begin;

2618

// } else if (currentType != null) {

2619

// memberLocation = currentType.Region.Begin;

2620

// } else {

2621

// memberLocation = location;

2622

// }

2623

var baseUnit = ParseStub("a");

2624

var tmpUnit = baseUnit;

2625

AstNode expr = baseUnit.GetNodeAt(

2626

location,

2627

n => n is IdentifierExpression || n is MemberReferenceExpression

2628

);

2629

2630

if (expr == null) {

2631

expr = baseUnit.GetNodeAt<AstType>(location.Line, location.Column - 1);

2632

}

2633

if (expr == null)

2634

expr = baseUnit.GetNodeAt<Identifier>(location.Line, location.Column - 1);

2635

// try insertStatement

2636

if (expr == null && baseUnit.GetNodeAt<EmptyStatement>(

2637

location.Line,

2638

location.Column

2639

) != null) {

2640

tmpUnit = baseUnit = ParseStub("a();", false);

2641

expr = baseUnit.GetNodeAt<InvocationExpression>(

2642

location.Line,

2643

location.Column + 1

2644

);

2645

}

2646

2647

if (expr == null) {

2648

baseUnit = ParseStub("()");

2649

expr = baseUnit.GetNodeAt<IdentifierExpression>(

2650

location.Line,

2651

location.Column - 1

2652

);

2653

if (expr == null) {

2654

expr = baseUnit.GetNodeAt<MemberType>(location.Line, location.Column - 1);

2655

}

2656

}

2657

2658

if (expr == null) {

2659

baseUnit = ParseStub("a", false);

2660

expr = baseUnit.GetNodeAt(

2661

location,

2662

n => n is IdentifierExpression || n is MemberReferenceExpression || n is CatchClause

2663

);

2664

}

2665

2666

// try statement

2667

if (expr == null) {

2668

expr = tmpUnit.GetNodeAt<SwitchStatement>(

2669

location.Line,

2670

location.Column - 1

2671

);

2672

baseUnit = tmpUnit;

2673

}

2674

2675

if (expr == null) {

2676

var block = tmpUnit.GetNodeAt<BlockStatement>(location);

2677

var node = block != null ? block.Statements.LastOrDefault() : null;

2678

2679

var forStmt = node != null ? node.PrevSibling as ForStatement : null;

2680

if (forStmt != null && forStmt.EmbeddedStatement.IsNull) {

2681

expr = forStmt;

2682

var id = new IdentifierExpression("stub");

2683

forStmt.EmbeddedStatement = new BlockStatement() { Statements = { new ExpressionStatement (id) }};

2684

expr = id;

2685

baseUnit = tmpUnit;

2686

}

2687

}

2688

2689

if (expr == null) {

2690

var forStmt = tmpUnit.GetNodeAt<ForeachStatement>(

2691

location.Line,

2692

location.Column - 3

2693

);

2694

if (forStmt != null && forStmt.EmbeddedStatement.IsNull) {

2695

forStmt.VariableNameToken = Identifier.Create("stub");

2696

expr = forStmt.VariableNameToken;

2697

baseUnit = tmpUnit;

2698

}

2699

}

2700

if (expr == null) {

2701

expr = tmpUnit.GetNodeAt<VariableInitializer>(

2702

location.Line,

2703

location.Column - 1

2704

);

2705

baseUnit = tmpUnit;

2706

}

2707

2708

// try parameter declaration type

2709

if (expr == null) {

2710

baseUnit = ParseStub(">", false, "{}");

2711

expr = baseUnit.GetNodeAt<TypeParameterDeclaration>(

2712

location.Line,

2713

location.Column - 1

2714

);

2715

}

2716

2717

// try parameter declaration method

2718

if (expr == null) {

2719

baseUnit = ParseStub("> ()", false, "{}");

2720

expr = baseUnit.GetNodeAt<TypeParameterDeclaration>(

2721

location.Line,

2722

location.Column - 1

2723

);

2724

}

2725

2726

// try expression in anonymous type "new { sample = x$" case

2727

if (expr == null) {

2728

baseUnit = ParseStub("a", false);

2729

expr = baseUnit.GetNodeAt<AnonymousTypeCreateExpression>(

2730

location.Line,

2731

location.Column

2732

);

2733

if (expr != null) {

2734

expr = baseUnit.GetNodeAt<Expression>(location.Line, location.Column) ?? expr;

2735

}

2736

if (expr == null) {

2737

expr = baseUnit.GetNodeAt<AstType>(location.Line, location.Column);

2738

}

2739

}

2740

2741

if (expr == null) {

2742

return null;

2743

}

2744

return new ExpressionResult(expr, baseUnit);

2745

}

2746

2747

ExpressionResult GetExpressionAt(int offset)

2748

{

2749

var parser = new CSharpParser();

2750

string text = this.document.GetText(0, this.offset);

2751

var sb = new StringBuilder(text);

2752

sb.Append("a;");

2753

AppendMissingClosingBrackets(sb, text, false);

2754

var stream = new System.IO.StringReader(sb.ToString());

2755

var completionUnit = parser.Parse(stream, CSharpParsedFile.FileName, 0);

2756

stream.Close();

2757

var loc = document.GetLocation(offset);

2758

2759

var expr = completionUnit.GetNodeAt(

2760

loc,

2761

n => n is Expression || n is VariableDeclarationStatement

2762

);

2763

if (expr == null) {

2764

return null;

2765

}

2766

return new ExpressionResult(expr, completionUnit);

2767

}

2768

2769

ExpressionResult GetNewExpressionAt(int offset)

2770

{

2771

var parser = new CSharpParser();

2772

string text = this.document.GetText(0, this.offset);

2773

var sb = new StringBuilder(text);

2774

sb.Append("a ();");

2775

AppendMissingClosingBrackets(sb, text, false);

2776

2777

var stream = new System.IO.StringReader(sb.ToString());

2778

var completionUnit = parser.Parse(stream, CSharpParsedFile.FileName, 0);

2779

stream.Close();

2780

var loc = document.GetLocation(offset);

2781

2782

var expr = completionUnit.GetNodeAt(loc, n => n is Expression);

2783

if (expr == null) {

2784

// try without ";"

2785

sb = new StringBuilder(text);

2786

sb.Append("a ()");

2787

AppendMissingClosingBrackets(sb, text, false);

2788

stream = new System.IO.StringReader(sb.ToString());

2789

completionUnit = parser.Parse(stream, CSharpParsedFile.FileName, 0);

2790

stream.Close();

2791

loc = document.GetLocation(offset);

2792

2793

expr = completionUnit.GetNodeAt(loc, n => n is Expression);

2794

if (expr == null) {

2795

return null;

2796

}

2797

}

2798

return new ExpressionResult(expr, completionUnit);

2799

}

2800

2801

2802

#endregion

2803

2804

#region Helper methods

2805

string GetPreviousToken(ref int i, bool allowLineChange)

2806

{

2807

char c;

2808

if (i <= 0) {

2809

return null;

2810

}

2811

2812

do {

2813

c = document.GetCharAt(--i);

2814

} while (i > 0 && char.IsWhiteSpace (c) && (allowLineChange ? true : c != '\n'));

2815

2816

if (i == 0) {

2817

return null;

2818

}

2819

2820

if (!char.IsLetterOrDigit(c)) {

2821

return new string(c, 1);

2822

}

2823

2824

int endOffset = i + 1;

2825

2826

do {

2827

c = document.GetCharAt(i - 1);

2828

if (!(char.IsLetterOrDigit(c) || c == '_')) {

2829

break;

2830

}

2831

2832

i--;

2833

} while (i > 0);

2834

2835

return document.GetText(i, endOffset - i);

2836

}

2837

2838

#endregion

2839

2840

#region Preprocessor

2841

2842

IEnumerable<ICompletionData> GetDirectiveCompletionData()

2843

{

2844

yield return factory.CreateLiteralCompletionData("if");

2845

yield return factory.CreateLiteralCompletionData("else");

2846

yield return factory.CreateLiteralCompletionData("elif");

2847

yield return factory.CreateLiteralCompletionData("endif");

2848

yield return factory.CreateLiteralCompletionData("define");

2849

yield return factory.CreateLiteralCompletionData("undef");

2850

yield return factory.CreateLiteralCompletionData("warning");

2851

yield return factory.CreateLiteralCompletionData("error");

2852

yield return factory.CreateLiteralCompletionData("pragma");

2853

yield return factory.CreateLiteralCompletionData("line");

2854

yield return factory.CreateLiteralCompletionData("line hidden");

2855

yield return factory.CreateLiteralCompletionData("line default");

2856

yield return factory.CreateLiteralCompletionData("region");

2857

yield return factory.CreateLiteralCompletionData("endregion");

2858

}

2859

#endregion

2860

2861

#region Xml Comments

2862

static readonly List<string> commentTags = new List<string>(new string[] {

2863

"c",

2864

"code",

2865

"example",

2866

"exception",

2867

"include",

2868

"list",

2869

"listheader",

2870

"item",

2871

"term",

2872

"description",

2873

"para",

2874

"param",

2875

"paramref",

2876

"permission",

2877

"remarks",

2878

"returns",

2879

"see",

2880

"seealso",

2881

"summary",

2882

"value"

2883

}

2884

);

2885

2886

IEnumerable<ICompletionData> GetXmlDocumentationCompletionData()

2887

{

2888

yield return factory.CreateLiteralCompletionData(

2889

"c",

2890

"Set text in a code-like font"

2891

);

2892

yield return factory.CreateLiteralCompletionData(

2893

"code",

2894

"Set one or more lines of source code or program output"

2895

);

2896

yield return factory.CreateLiteralCompletionData(

2897

"example",

2898

"Indicate an example"

2899

);

2900

yield return factory.CreateLiteralCompletionData(

2901

"exception",

2902

"Identifies the exceptions a method can throw",

2903

"exception cref=\"|\"></exception>"

2904

);

2905

yield return factory.CreateLiteralCompletionData(

2906

"include",

2907

"Includes comments from a external file",

2908

"include file=\"|\" path=\"\">"

2909

);

2910

yield return factory.CreateLiteralCompletionData(

2911

"list",

2912

"Create a list or table",

2913

"list type=\"|\">"

2914

);

2915

yield return factory.CreateLiteralCompletionData(

2916

"listheader",

2917

"Define the heading row"

2918

);

2919

yield return factory.CreateLiteralCompletionData(

2920

"item",

2921

"Defines list or table item"

2922

);

2923

2924

yield return factory.CreateLiteralCompletionData("term", "A term to define");

2925

yield return factory.CreateLiteralCompletionData(

2926

"description",

2927

"Describes a list item"

2928

);

2929

yield return factory.CreateLiteralCompletionData(

2930

"para",

2931

"Permit structure to be added to text"

2932

);

2933

2934

yield return factory.CreateLiteralCompletionData(

2935

"param",

2936

"Describe a parameter for a method or constructor",

2937

"param name=\"|\">"

2938

);

2939

yield return factory.CreateLiteralCompletionData(

2940

"paramref",

2941

"Identify that a word is a parameter name",

2942

"paramref name=\"|\"/>"

2943

);

2944

2945

yield return factory.CreateLiteralCompletionData(

2946

"permission",

2947

"Document the security accessibility of a member",

2948

"permission cref=\"|\""

2949

);

2950

yield return factory.CreateLiteralCompletionData(

2951

"remarks",

2952

"Describe a type"

2953

);

2954

yield return factory.CreateLiteralCompletionData(

2955

"returns",

2956

"Describe the return value of a method"

2957

);

2958

yield return factory.CreateLiteralCompletionData(

2959

"see",

2960

"Specify a link",

2961

"see cref=\"|\"/>"

2962

);

2963

yield return factory.CreateLiteralCompletionData(

2964

"seealso",

2965

"Generate a See Also entry",

2966

"seealso cref=\"|\"/>"

2967

);

2968

yield return factory.CreateLiteralCompletionData(

2969

"summary",

2970

"Describe a member of a type"

2971

);

2972

yield return factory.CreateLiteralCompletionData(

2973

"typeparam",

2974

"Describe a type parameter for a generic type or method"

2975

);

2976

yield return factory.CreateLiteralCompletionData(

2977

"typeparamref",

2978

"Identify that a word is a type parameter name"

2979

);

2980

yield return factory.CreateLiteralCompletionData(

2981

"value",

2982

"Describe a property"

2983

);

2984

}

2985

#endregion

2986

2987

#region Keywords

2988

static string[] expressionLevelKeywords = new string [] {

2989

"as",

2990

"is",

2991

"else",

2992

"out",

2993

"ref",

2994

"null",

2995

"delegate",

2996

"default"

2997

};

2998

static string[] primitiveTypesKeywords = new string [] {

2999

"void",

3000

"object",

3001

"bool",

3002

"byte",

3003

"sbyte",

3004

"char",

3005

"short",

3006

"int",

3007

"long",

3008

"ushort",

3009

"uint",

3010

"ulong",

3011

"float",

3012

"double",

3013

"decimal",

3014

"string"

3015

};

3016

static string[] statementStartKeywords = new string [] { "base", "new", "sizeof", "this",

3017

"true", "false", "typeof", "checked", "unchecked", "from", "break", "checked",

3018

"unchecked", "const", "continue", "do", "finally", "fixed", "for", "foreach",

3019

"goto", "if", "lock", "return", "stackalloc", "switch", "throw", "try", "unsafe",

3020

"using", "while", "yield", "dynamic", "var", "dynamic",

3021

"catch"

3022

};

3023

static string[] globalLevelKeywords = new string [] {

3024

"namespace", "using", "extern", "public", "internal",

3025

"class", "interface", "struct", "enum", "delegate",

3026

"abstract", "sealed", "static", "unsafe", "partial"

3027

};

3028

static string[] accessorModifierKeywords = new string [] {

3029

"public", "internal", "protected", "private"

3030

};

3031

static string[] typeLevelKeywords = new string [] {

3032

"public", "internal", "protected", "private",

3033

"class", "interface", "struct", "enum", "delegate",

3034

"abstract", "sealed", "static", "unsafe", "partial",

3035

"const", "event", "extern", "fixed","new",

3036

"operator", "explicit", "implicit",

3037

"override", "readonly", "virtual", "volatile"

3038

};

3039

static string[] linqKeywords = new string[] {

3040

"from",

3041

"where",

3042

"select",

3043

"group",

3044

"into",

3045

"orderby",

3046

"join",

3047

"let",

3048

"in",

3049

"on",

3050

"equals",

3051

"by",

3052

"ascending",

3053

"descending"

3054

};

3055

static string[] parameterTypePredecessorKeywords = new string[] {

3056

"out",

3057

"ref",

3058

"params"

3059

};

3060

#endregion

3061

}

3062

}

3063

Older »