← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CSharpCompletionTextEditorExtension.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CSharpCompletionTextEditorExtension.cs
47
47
using ICSharpCode.NRefactory.CSharp.Completion;
48
48
using ICSharpCode.NRefactory.CSharp.TypeSystem;
49
49
using Mono.TextEditor;
 
50
using MonoDevelop.Components.Commands;
 
51
using MonoDevelop.CodeGeneration;
50
52
 
51
53
namespace MonoDevelop.CSharp.Completion
52
54
{
53
55
        
54
 
        public class CSharpCompletionTextEditorExtension : CompletionTextEditorExtension, ICompletionDataFactory, IParameterCompletionDataFactory, ITextEditorMemberPositionProvider
 
56
        public class CSharpCompletionTextEditorExtension : CompletionTextEditorExtension, IParameterCompletionDataFactory, ITextEditorMemberPositionProvider
55
57
        {
56
 
                internal Mono.TextEditor.TextEditorData textEditorData;
 
58
                internal Mono.TextEditor.TextEditorData TextEditorData {
 
59
                        get {
 
60
                                var doc = Document;
 
61
                                if (doc == null)
 
62
                                        return null;
 
63
                                return doc.Editor;
 
64
                        }
 
65
                }
57
66
                
58
 
                CompilationUnit unit;
59
 
                static readonly CompilationUnit emptyUnit = new CompilationUnit ();
60
 
                CompilationUnit Unit {
 
67
                SyntaxTree unit;
 
68
                static readonly SyntaxTree emptyUnit = new SyntaxTree ();
 
69
                SyntaxTree Unit {
61
70
                        get {
62
71
                                return unit ?? emptyUnit;
63
72
                        }
71
80
                                return base.document;
72
81
                        }
73
82
                }
 
83
 
 
84
                public ICompilation UnresolvedFileCompilation {
 
85
                        get;
 
86
                        set;
 
87
                }
74
88
                
75
 
                public CSharpParsedFile CSharpParsedFile {
 
89
                public CSharpUnresolvedFile CSharpUnresolvedFile {
76
90
                        get;
77
91
                        set;
78
92
                }
99
113
                public CSharpFormattingPolicy FormattingPolicy {
100
114
                        get {
101
115
                                if (policy == null) {
102
 
                                        IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
 
116
                                        IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (MonoDevelop.CSharp.Formatting.CSharpFormatter.MimeType);
103
117
                                        if (Document.Project != null && Document.Project.Policies != null) {
104
118
                                                policy = base.Document.Project.Policies.Get<CSharpFormattingPolicy> (types);
105
119
                                        } else {
126
140
                public override void Initialize ()
127
141
                {
128
142
                        base.Initialize ();
129
 
                        textEditorData = Document.Editor;
130
143
                        var parsedDocument = document.ParsedDocument;
131
144
                        if (parsedDocument != null) {
132
 
                                this.Unit = parsedDocument.GetAst<CompilationUnit> ();
133
 
                                this.CSharpParsedFile = parsedDocument.ParsedFile as CSharpParsedFile;
 
145
                                this.Unit = parsedDocument.GetAst<SyntaxTree> ();
 
146
                                this.UnresolvedFileCompilation = Document.Compilation;
 
147
                                this.CSharpUnresolvedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
134
148
                        }
135
149
                        
136
150
                        Document.DocumentParsed += HandleDocumentParsed; 
137
151
                }
138
152
                
 
153
                [CommandUpdateHandler (CodeGenerationCommands.ShowCodeGenerationWindow)]
 
154
                public void CheckShowCodeGenerationWindow (CommandInfo info)
 
155
                {
 
156
                        info.Enabled = Document.Editor != null && Document.GetContent<ICompletionWidget> () != null;
 
157
                }
 
158
 
 
159
                [CommandHandler (CodeGenerationCommands.ShowCodeGenerationWindow)]
 
160
                public void ShowCodeGenerationWindow ()
 
161
                {
 
162
                        var completionWidget = Document.GetContent<ICompletionWidget> ();
 
163
                        if (completionWidget == null)
 
164
                                return;
 
165
                        CodeCompletionContext completionContext = completionWidget.CreateCodeCompletionContext (Document.Editor.Caret.Offset);
 
166
                        GenerateCodeWindow.ShowIfValid (Document, completionContext);
 
167
                }
 
168
 
139
169
                public override void Dispose ()
140
170
                {
141
171
                        unit = null;
142
 
                        CSharpParsedFile = null;
 
172
                        CSharpUnresolvedFile = null;
 
173
                        UnresolvedFileCompilation = null;
143
174
                        Document.DocumentParsed -= HandleDocumentParsed; 
144
175
                        base.Dispose ();
145
176
                }
151
182
                                return;
152
183
                        var newTree = TypeSystemSegmentTree.Create (Document);
153
184
                        if (typeSystemSegmentTree != null)
154
 
                                typeSystemSegmentTree.RemoveListener (document.Editor.Document);
 
185
                                typeSystemSegmentTree.RemoveListener ();
155
186
                        typeSystemSegmentTree = newTree;
156
187
                        typeSystemSegmentTree.InstallListener (document.Editor.Document);
157
188
                        
158
 
                        this.Unit = newDocument.GetAst<CompilationUnit> ();
159
 
                        this.CSharpParsedFile = newDocument.ParsedFile as CSharpParsedFile;
 
189
                        this.Unit = newDocument.GetAst<SyntaxTree> ();
 
190
                        this.CSharpUnresolvedFile = newDocument.ParsedFile as CSharpUnresolvedFile;
 
191
                        this.UnresolvedFileCompilation = Document.Compilation;
160
192
                        if (TypeSegmentTreeUpdated != null)
161
193
                                TypeSegmentTreeUpdated (this, EventArgs.Empty);
162
194
                }
163
195
                public event EventHandler TypeSegmentTreeUpdated;
 
196
 
 
197
                public void UpdateParsedDocument ()
 
198
                {
 
199
                        HandleDocumentParsed (null, null);
 
200
                }
164
201
                
165
202
                public override bool KeyPress (Gdk.Key key, char keyChar, Gdk.ModifierType modifier)
166
203
                {
201
238
                                //                              timer.Dispose ();
202
239
                        }
203
240
                }
 
241
 
 
242
                class CSharpCompletionDataList : CompletionDataList
 
243
                {
 
244
                        public CSharpResolver Resolver {
 
245
                                get;
 
246
                                set;
 
247
                        }
 
248
                }
 
249
 
 
250
                interface IListData
 
251
                {
 
252
                        CSharpCompletionDataList List { get; set; }
 
253
                }
204
254
                
205
255
                ICompletionDataList InternalHandleCodeCompletion (CodeCompletionContext completionContext, char completionChar, bool ctrlSpace, ref int triggerWordLength)
206
256
                {
207
 
/*                      
208
 
                        if (textEditorData.CurrentMode is CompletionTextLinkMode) {
209
 
                                if (!((CompletionTextLinkMode)textEditorData.CurrentMode).TriggerCodeCompletion)
 
257
                        var data = TextEditorData;
 
258
                        if (data.CurrentMode is TextLinkEditMode) {
 
259
                                if (((TextLinkEditMode)data.CurrentMode).TextLinkMode == TextLinkMode.EditIdentifier)
210
260
                                        return null;
211
 
                        } else if (textEditorData.CurrentMode is Mono.TextEditor.TextLinkEditMode) {
212
 
                                return null;
213
 
                        }*/
214
 
                        if (Unit == null || CSharpParsedFile == null)
215
 
                                return null;
216
 
                        var list = new CompletionDataList ();
 
261
                        }
 
262
                        if (Unit == null || CSharpUnresolvedFile == null)
 
263
                                return null;
 
264
                        if(typeSystemSegmentTree == null)
 
265
                                return null;
 
266
 
 
267
                        var list = new CSharpCompletionDataList ();
 
268
                        list.Resolver = CSharpUnresolvedFile != null ? CSharpUnresolvedFile.GetResolver (UnresolvedFileCompilation, Document.Editor.Caret.Location) : new CSharpResolver (Compilation);
 
269
                        var ctx = CSharpUnresolvedFile.GetTypeResolveContext (UnresolvedFileCompilation, data.Caret.Location) as CSharpTypeResolveContext;
 
270
 
217
271
                        var engine = new CSharpCompletionEngine (
218
 
                                textEditorData.Document,
219
 
                                this,
 
272
                                data.Document,
 
273
                                typeSystemSegmentTree,
 
274
                                new CompletionDataFactory (this, new CSharpResolver (ctx)),
220
275
                                Document.GetProjectContext (),
221
 
                                CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext,
222
 
                                Unit,
223
 
                                CSharpParsedFile
 
276
                                ctx
224
277
                        );
225
 
                        engine.MemberProvider = typeSystemSegmentTree;
 
278
 
 
279
                        if (Document.HasProject) {
 
280
                                var configuration = Document.Project.GetConfiguration (MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration;
 
281
                                var par = configuration != null ? configuration.CompilationParameters as CSharpCompilerParameters : null;
 
282
                                if (par != null)
 
283
                                        engine.LanguageVersion = MonoDevelop.CSharp.Parser.TypeSystemParser.ConvertLanguageVersion (par.LangVersion);
 
284
                        }
 
285
 
226
286
                        engine.FormattingPolicy = FormattingPolicy.CreateOptions ();
227
 
                        engine.EolMarker = textEditorData.EolMarker;
228
 
                        engine.IndentString = textEditorData.Options.IndentationString;
229
 
                        list.AddRange (engine.GetCompletionData (completionContext.TriggerOffset, ctrlSpace));
 
287
                        engine.EolMarker = data.EolMarker;
 
288
                        engine.IndentString = data.Options.IndentationString;
 
289
                        try {
 
290
                                foreach (var cd in engine.GetCompletionData (completionContext.TriggerOffset, ctrlSpace)) {
 
291
                                        list.Add (cd);
 
292
                                        if (cd is IListData)
 
293
                                                ((IListData)cd).List = list;
 
294
                                }
 
295
                        } catch (Exception e) {
 
296
                                LoggingService.LogError ("Error while getting completion data.", e);
 
297
                        }
230
298
                        list.AutoCompleteEmptyMatch = engine.AutoCompleteEmptyMatch;
 
299
                        list.AutoCompleteEmptyMatchOnCurlyBrace = engine.AutoCompleteEmptyMatchOnCurlyBracket;
231
300
                        list.AutoSelect = engine.AutoSelect;
232
301
                        list.DefaultCompletionString = engine.DefaultCompletionString;
233
302
                        list.CloseOnSquareBrackets = engine.CloseOnSquareBrackets;
239
308
                public override ICompletionDataList CodeCompletionCommand (CodeCompletionContext completionContext)
240
309
                {
241
310
                        int triggerWordLength = 0;
242
 
                        char ch = completionContext.TriggerOffset > 0 ? textEditorData.GetCharAt (completionContext.TriggerOffset - 1) : '\0';
 
311
                        char ch = completionContext.TriggerOffset > 0 ? TextEditorData.GetCharAt (completionContext.TriggerOffset - 1) : '\0';
243
312
                        return InternalHandleCodeCompletion (completionContext, ch, true, ref triggerWordLength);
244
313
                }
 
314
 
 
315
                static bool HasAllUsedParameters (IParameterDataProvider provider, List<string> list, int n)
 
316
                {
 
317
                        int pc = provider.GetParameterCount (n);
 
318
                        foreach (var usedParam in list) {
 
319
                                bool found = false;
 
320
                                for (int m = 0; m < pc; m++) {
 
321
                                        if (usedParam == provider.GetParameterName (n, m)){
 
322
                                                found = true;
 
323
                                                break;
 
324
                                        }
 
325
                                }
 
326
                                if (!found)
 
327
                                        return false;
 
328
                        }
 
329
                        return true;
 
330
                }
 
331
                public override int GuessBestMethodOverload (IParameterDataProvider provider, int currentOverload)
 
332
                {
 
333
                        var engine = new CSharpParameterCompletionEngine (
 
334
                                TextEditorData.Document,
 
335
                                typeSystemSegmentTree,
 
336
                                this,
 
337
                                Document.GetProjectContext (),
 
338
                                CSharpUnresolvedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
 
339
                                );
 
340
                        List<string> list;
 
341
                        int cparam = engine.GetCurrentParameterIndex (provider.StartOffset, document.Editor.Caret.Offset, out list);
 
342
                        if (cparam > provider.GetParameterCount (currentOverload) && !provider.AllowParameterList (currentOverload) || !HasAllUsedParameters (provider, list, currentOverload)) {
 
343
                                // Look for an overload which has more parameters
 
344
                                int bestOverload = -1;
 
345
                                int bestParamCount = int.MaxValue;
 
346
                                for (int n = 0; n < provider.Count; n++) {
 
347
                                        int pc = provider.GetParameterCount (n);
 
348
                                        if (pc < bestParamCount && pc >= cparam) {
 
349
 
 
350
                                                if (HasAllUsedParameters (provider, list, n)) {
 
351
                                                        bestOverload = n;
 
352
                                                        bestParamCount = pc;
 
353
                                                }
 
354
                                        }
 
355
 
 
356
 
 
357
                                }
 
358
                                if (bestOverload == -1) {
 
359
                                        for (int n=0; n<provider.Count; n++) {
 
360
                                                if (provider.AllowParameterList (n) && HasAllUsedParameters (provider, list, n)) {
 
361
                                                        bestOverload = n;
 
362
                                                        break;
 
363
                                                }
 
364
                                        }
 
365
                                }
 
366
                                return bestOverload;
 
367
                        }
 
368
                        return -1;
 
369
                }
 
370
 
245
371
                
246
372
                static bool ContainsPublicConstructors (ITypeDefinition t)
247
373
                {
356
482
//                      }
357
483
//              }
358
484
                
359
 
                public override IParameterDataProvider HandleParameterCompletion (CodeCompletionContext completionContext, char completionChar)
 
485
                public override ParameterDataProvider HandleParameterCompletion (CodeCompletionContext completionContext, char completionChar)
360
486
                {
361
487
                        if (!EnableCodeCompletion)
362
488
                                return null;
363
 
                        if (Unit == null || CSharpParsedFile == null)
 
489
                        if (Unit == null || CSharpUnresolvedFile == null)
364
490
                                return null;
365
491
                        try {
366
492
                                var engine = new CSharpParameterCompletionEngine (
367
 
                                        textEditorData.Document,
 
493
                                        TextEditorData.Document,
 
494
                                        typeSystemSegmentTree,
368
495
                                        this,
369
496
                                        Document.GetProjectContext (),
370
 
                                        CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext,
371
 
                                        Unit,
372
 
                                        CSharpParsedFile
 
497
                                        CSharpUnresolvedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
373
498
                                );
374
 
                                engine.MemberProvider = typeSystemSegmentTree;
375
 
                                return engine.GetParameterDataProvider (completionContext.TriggerOffset, completionChar);
 
499
                                return engine.GetParameterDataProvider (completionContext.TriggerOffset, completionChar) as ParameterDataProvider;
376
500
                        } catch (Exception e) {
377
501
                                LoggingService.LogError ("Unexpected parameter completion exception." + Environment.NewLine + 
378
502
                                        "FileName: " + Document.FileName + Environment.NewLine + 
388
512
                
389
513
                List<string> GetUsedNamespaces ()
390
514
                {
391
 
                        var scope = CSharpParsedFile.GetUsingScope (document.Editor.Caret.Location);
 
515
                        var scope = CSharpUnresolvedFile.GetUsingScope (document.Editor.Caret.Location);
392
516
                        var result = new List<string> ();
393
517
                        while (scope != null) {
394
518
                                result.Add (scope.NamespaceName);
395
 
                                var ctx = CSharpParsedFile.GetResolver (Document.Compilation, scope.Region.Begin);
 
519
                                var ctx = CSharpUnresolvedFile.GetResolver (Document.Compilation, scope.Region.Begin);
396
520
                                foreach (var u in scope.Usings) {
397
521
                                        var ns = u.ResolveNamespace (ctx);
398
522
                                        if (ns == null)
407
531
                public override bool GetParameterCompletionCommandOffset (out int cpos)
408
532
                {
409
533
                        var engine = new CSharpParameterCompletionEngine (
410
 
                                textEditorData.Document,
 
534
                                TextEditorData.Document,
 
535
                                typeSystemSegmentTree,
411
536
                                this,
412
537
                                Document.GetProjectContext (),
413
 
                                CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext,
414
 
                                Unit,
415
 
                                CSharpParsedFile
 
538
                                CSharpUnresolvedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
416
539
                        );
417
 
                        engine.MemberProvider = typeSystemSegmentTree;
418
540
                        engine.SetOffset (document.Editor.Caret.Offset);
419
541
                        return engine.GetParameterCompletionCommandOffset (out cpos);
420
542
                }
422
544
                public override int GetCurrentParameterIndex (int startOffset)
423
545
                {
424
546
                        var engine = new CSharpParameterCompletionEngine (
425
 
                                textEditorData.Document,
 
547
                                TextEditorData.Document,
 
548
                                typeSystemSegmentTree,
426
549
                                this,
427
550
                                Document.GetProjectContext (),
428
 
                                CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext,
429
 
                                Unit,
430
 
                                CSharpParsedFile
431
 
                        );
432
 
                        engine.MemberProvider = typeSystemSegmentTree;
433
 
                        return engine.GetCurrentParameterIndex (startOffset, document.Editor.Caret.Offset);
 
551
                                CSharpUnresolvedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
 
552
                                );
 
553
                        List<string> list;
 
554
                        return engine.GetCurrentParameterIndex (startOffset, document.Editor.Caret.Offset, out list);
434
555
                }
435
556
                /*
436
557
                internal int GetCurrentParameterIndex (ICompletionWidget widget, int offset, int memberStart)
476
597
                        
477
598
                        return parentheses != 1 || bracket > 0 ? -1 : index;
478
599
                }*/
479
 
                
 
600
 
 
601
 
480
602
                #region ICompletionDataFactory implementation
481
 
                ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IEntity entity)
482
 
                {
483
 
                        return new MemberCompletionData (this, entity, OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | OutputFlags.IncludeParameterName) {
484
 
                                HideExtensionParameter = true
485
 
                        };
486
 
                }
487
 
 
488
 
                ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IEntity entity, string text)
489
 
                {
490
 
                        return new CompletionData (text, entity.GetStockIcon (), null, text);
491
 
                }
492
 
                
493
 
                ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IUnresolvedEntity entity)
494
 
                {
495
 
                        var context = CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location);
496
 
                        var resolvedEntity = ((IUnresolvedMember)entity).CreateResolved (context);
497
 
                        
498
 
                        return new MemberCompletionData (this, resolvedEntity, OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | OutputFlags.IncludeParameterName) {
499
 
                                HideExtensionParameter = true
500
 
                        };
501
 
                }
502
 
 
503
 
                ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IUnresolvedEntity entity, string text)
504
 
                {
505
 
                        var context = CSharpParsedFile.GetTypeResolveContext (Document.Compilation, document.Editor.Caret.Location);
506
 
                        var resolvedEntity = ((IUnresolvedMember)entity).CreateResolved (context);
507
 
                        return new MemberCompletionData (this, resolvedEntity, OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | OutputFlags.IncludeParameterName) {
508
 
                                HideExtensionParameter = true
509
 
                        };
510
 
                }
511
 
 
512
 
                ICompletionData ICompletionDataFactory.CreateTypeCompletionData (IType type, string shortType)
513
 
                {
514
 
                        var result = new CompletionData (shortType, type.GetStockIcon ());
515
 
                        if (!(type is ParameterizedType) && type.TypeParameterCount > 0) {
516
 
                                var sb = new StringBuilder (shortType);
517
 
                                sb.Append ("<");
518
 
                                for (int i = 0; i < type.TypeParameterCount; i++) {
519
 
                                        if (i > 0)
520
 
                                                sb.Append (", ");
521
 
                                        sb.Append (GetAmbience ().GetString (type.GetDefinition ().TypeParameters[i], OutputFlags.ClassBrowserEntries));
522
 
                                }
523
 
                                sb.Append (">");
524
 
                                result.DisplayText = sb.ToString ();
525
 
                        }
526
 
                        return result;
527
 
                }
528
 
                
529
 
                ICompletionData ICompletionDataFactory.CreateTypeCompletionData (IUnresolvedTypeDefinition type, string shortType)
530
 
                {
531
 
                        return new CompletionData (shortType, type.GetStockIcon ());
532
 
                }
533
 
                
534
 
                ICompletionData ICompletionDataFactory.CreateLiteralCompletionData (string title, string description, string insertText)
535
 
                {
536
 
                        return new CompletionData (title, "md-keyword", description, insertText ?? title);
537
 
                }
538
 
 
539
 
                ICompletionData ICompletionDataFactory.CreateNamespaceCompletionData (string name)
540
 
                {
541
 
                        return new CompletionData (name, AstStockIcons.Namespace);
542
 
                }
543
 
 
544
 
                ICompletionData ICompletionDataFactory.CreateVariableCompletionData (IVariable variable)
545
 
                {
546
 
                        return new VariableCompletionData (variable);
547
 
                }
548
 
 
549
 
                ICompletionData ICompletionDataFactory.CreateVariableCompletionData (IUnresolvedTypeParameter parameter)
550
 
                {
551
 
                        return new CompletionData (parameter.Name, parameter.GetStockIcon ());
552
 
                }
553
 
 
554
 
                ICompletionData ICompletionDataFactory.CreateEventCreationCompletionData (string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
555
 
                {
556
 
                        return new EventCreationCompletionData (this, varName, delegateType, evt, parameterDefinition, currentMember, currentType);
557
 
                }
558
 
                
559
 
                ICompletionData ICompletionDataFactory.CreateNewOverrideCompletionData (int declarationBegin, IUnresolvedTypeDefinition type, IMember m)
560
 
                {
561
 
                        return new NewOverrideCompletionData (this, declarationBegin, type, m);
562
 
                }
563
 
                ICompletionData ICompletionDataFactory.CreateNewPartialCompletionData (int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember m)
564
 
                {
565
 
                        var ctx = CSharpParsedFile.GetTypeResolveContext (Compilation, document.Editor.Caret.Location);
566
 
                        return new NewOverrideCompletionData (this, declarationBegin, type, m.CreateResolved (ctx));
567
 
                }
568
 
                IEnumerable<ICompletionData> ICompletionDataFactory.CreateCodeTemplateCompletionData ()
569
 
                {
570
 
                        var result = new CompletionDataList ();
571
 
                        CodeTemplateService.AddCompletionDataForMime ("text/x-csharp", result);
572
 
                        return result;
573
 
                }
574
 
                
575
 
                IEnumerable<ICompletionData> ICompletionDataFactory.CreatePreProcessorDefinesCompletionData ()
576
 
                {
577
 
                        var project = document.Project;
578
 
                        if (project == null)
579
 
                                yield break;
580
 
                        var configuration = project.GetConfiguration (MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration;
581
 
                        var par = configuration != null ? configuration.CompilationParameters as CSharpCompilerParameters : null;
582
 
                        if (par == null)
583
 
                                yield break;
584
 
                        foreach (var define in par.DefineSymbols.Split (';', ',', ' ', '\t').Where (s => !string.IsNullOrWhiteSpace (s)))
585
 
                                yield return new CompletionData (define, "md-keyword");
586
 
                                
 
603
                class CompletionDataFactory : ICompletionDataFactory
 
604
                {
 
605
                        CSharpCompletionTextEditorExtension ext;
 
606
//                      readonly CSharpResolver state;
 
607
                        readonly TypeSystemAstBuilder builder;
 
608
 
 
609
                        public CompletionDataFactory (CSharpCompletionTextEditorExtension ext, CSharpResolver state)
 
610
                        {
 
611
//                              this.state = state;
 
612
                                builder = new TypeSystemAstBuilder(state);
 
613
                                this.ext = ext;
 
614
                        }
 
615
                        
 
616
                        ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IEntity entity)
 
617
                        {
 
618
                                return new MemberCompletionData (ext, entity, OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | OutputFlags.IncludeParameterName) {
 
619
                                        HideExtensionParameter = true
 
620
                                };
 
621
                        }
 
622
 
 
623
                        class GenericTooltipCompletionData : CompletionData, IListData
 
624
                        {
 
625
                                readonly Func<CSharpCompletionDataList, bool, TooltipInformation> tooltipFunc;
 
626
 
 
627
                                #region IListData implementation
 
628
 
 
629
                                CSharpCompletionDataList list;
 
630
                                public CSharpCompletionDataList List {
 
631
                                        get {
 
632
                                                return list;
 
633
                                        }
 
634
                                        set {
 
635
                                                list = value;
 
636
                                                if (overloads != null) {
 
637
                                                        foreach (var overload in overloads.Skip (1)) {
 
638
                                                                var ld = overload as IListData;
 
639
                                                                if (ld != null)
 
640
                                                                        ld.List = list;
 
641
                                                        }
 
642
                                                }
 
643
                                        }
 
644
                                }
 
645
 
 
646
                                #endregion
 
647
 
 
648
                                public GenericTooltipCompletionData (Func<CSharpCompletionDataList, bool, TooltipInformation> tooltipFunc, string text, string icon) : base (text, icon)
 
649
                                {
 
650
                                        this.tooltipFunc = tooltipFunc;
 
651
                                }
 
652
 
 
653
                                public GenericTooltipCompletionData (Func<CSharpCompletionDataList, bool, TooltipInformation> tooltipFunc, string text, string icon, string description, string completionText) : base (text, icon, description, completionText)
 
654
                                {
 
655
                                        this.tooltipFunc = tooltipFunc;
 
656
                                }
 
657
 
 
658
                                public override TooltipInformation CreateTooltipInformation (bool smartWrap)
 
659
                                {
 
660
                                        return tooltipFunc (List, smartWrap);
 
661
                                }
 
662
 
 
663
                                protected List<ICompletionData> overloads;
 
664
                                public override bool HasOverloads {
 
665
                                        get { return overloads != null && overloads.Count > 0; }
 
666
                                }
 
667
 
 
668
                                public override IEnumerable<ICompletionData> OverloadedData {
 
669
                                        get {
 
670
                                                return overloads;
 
671
                                        }
 
672
                                }
 
673
 
 
674
                                public override void AddOverload (ICSharpCode.NRefactory.Completion.ICompletionData data)
 
675
                                {
 
676
                                        if (overloads == null) {
 
677
                                                overloads = new List<ICompletionData> ();
 
678
                                                overloads.Add (this);
 
679
                                        }
 
680
                                        overloads.Add (data);
 
681
                                }
 
682
 
 
683
                                public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier)
 
684
                                {
 
685
                                        var currentWord = GetCurrentWord (window);
 
686
                                        if (CompletionText == "new()" && keyChar == '(') {
 
687
                                                window.CompletionWidget.SetCompletionText (window.CodeCompletionContext, currentWord, "new");
 
688
                                        } else {
 
689
                                                window.CompletionWidget.SetCompletionText (window.CodeCompletionContext, currentWord, CompletionText);
 
690
                                        }
 
691
                                }
 
692
 
 
693
                        }
 
694
 
 
695
                        class LazyGenericTooltipCompletionData : GenericTooltipCompletionData
 
696
                        {
 
697
                                Lazy<string> displayText;
 
698
                                public override string DisplayText {
 
699
                                        get {
 
700
                                                return displayText.Value;
 
701
                                        }
 
702
                                }
 
703
 
 
704
                                public override string CompletionText {
 
705
                                        get {
 
706
                                                return displayText.Value;
 
707
                                        }
 
708
                                }
 
709
 
 
710
                                public LazyGenericTooltipCompletionData (Func<CSharpCompletionDataList, bool, TooltipInformation> tooltipFunc, Lazy<string> displayText, string icon) : base (tooltipFunc, null, icon)
 
711
                                {
 
712
                                        this.displayText = displayText;
 
713
                                }
 
714
                        }
 
715
 
 
716
                        class TypeCompletionData : LazyGenericTooltipCompletionData, IListData
 
717
                        {
 
718
                                IType type;
 
719
                                CSharpCompletionTextEditorExtension ext;
 
720
                                CSharpUnresolvedFile file;
 
721
                                ICompilation compilation;
 
722
//                              CSharpResolver resolver;
 
723
 
 
724
                                string IdString {
 
725
                                        get {
 
726
                                                return DisplayText + type.TypeParameterCount;
 
727
                                        }
 
728
                                }
 
729
 
 
730
                                public override string CompletionText {
 
731
                                        get {
 
732
                                                if (type.TypeParameterCount > 0 && !type.IsParameterized)
 
733
                                                        return type.Name;
 
734
                                                return base.CompletionText;
 
735
                                        }
 
736
                                }
 
737
 
 
738
                                public override TooltipInformation CreateTooltipInformation (bool smartWrap)
 
739
                                {
 
740
                                        var def = type.GetDefinition ();
 
741
                                        var result = def != null ? MemberCompletionData.CreateTooltipInformation (compilation, file, List.Resolver, ext.TextEditorData, ext.FormattingPolicy, def, smartWrap)  : new TooltipInformation ();
 
742
                                        if (ConflictingTypes != null) {
 
743
                                                var conflicts = new StringBuilder ();
 
744
                                                var sig = new SignatureMarkupCreator (List.Resolver, ext.FormattingPolicy.CreateOptions ());
 
745
                                                for (int i = 0; i < ConflictingTypes.Count; i++) {
 
746
                                                        var ct = ConflictingTypes[i];
 
747
                                                        if (i > 0)
 
748
                                                                conflicts.AppendLine (",");
 
749
//                                                      if ((i + 1) % 5 == 0)
 
750
//                                                              conflicts.Append (Environment.NewLine + "\t");
 
751
                                                        conflicts.Append (sig.GetTypeReferenceString (((TypeCompletionData)ct).type));
 
752
                                                }
 
753
                                                result.AddCategory ("Type Conflicts", conflicts.ToString ());
 
754
                                        }
 
755
                                        return result;
 
756
                                }
 
757
 
 
758
                                public TypeCompletionData (IType type, CSharpCompletionTextEditorExtension ext, Lazy<string> displayText, string icon) : base (null, displayText, icon)
 
759
                                {
 
760
                                        this.type = type;
 
761
                                        this.ext = ext;
 
762
                                        this.file = ext.CSharpUnresolvedFile;
 
763
                                        this.compilation = ext.UnresolvedFileCompilation;
 
764
                                }
 
765
 
 
766
                                Dictionary<string, ICSharpCode.NRefactory.Completion.ICompletionData> addedDatas = new Dictionary<string, ICSharpCode.NRefactory.Completion.ICompletionData> ();
 
767
 
 
768
                                List<ICompletionData> ConflictingTypes = null;
 
769
 
 
770
                                public override void AddOverload (ICSharpCode.NRefactory.Completion.ICompletionData data)
 
771
                                {
 
772
                                        if (overloads == null)
 
773
                                                addedDatas [IdString] = this;
 
774
 
 
775
                                        if (data is TypeCompletionData) {
 
776
                                                string id = ((TypeCompletionData)data).IdString;
 
777
                                                ICompletionData oldData;
 
778
                                                if (addedDatas.TryGetValue (id, out oldData)) {
 
779
                                                        var old = (TypeCompletionData)oldData;
 
780
                                                        if (old.ConflictingTypes == null)
 
781
                                                                old.ConflictingTypes = new List<ICompletionData> ();
 
782
                                                        old.ConflictingTypes.Add (data);
 
783
                                                        return;
 
784
                                                }
 
785
                                                addedDatas [id] = data;
 
786
                                        }
 
787
 
 
788
                                        base.AddOverload (data);
 
789
                                }
 
790
 
 
791
                        }
 
792
 
 
793
                        ICompletionData ICompletionDataFactory.CreateEntityCompletionData (IEntity entity, string text)
 
794
                        {
 
795
                                return new GenericTooltipCompletionData ((list, sw) => MemberCompletionData.CreateTooltipInformation (ext, list.Resolver, entity, sw), text, entity.GetStockIcon ());
 
796
                        }
 
797
 
 
798
                        ICompletionData ICompletionDataFactory.CreateTypeCompletionData (IType type, bool showFullName, bool isInAttributeContext)
 
799
                        {
 
800
                                Lazy<string> displayText = new Lazy<string> (delegate {
 
801
                                        string name = showFullName ? builder.ConvertType(type).ToString() : type.Name; 
 
802
                                        if (isInAttributeContext && name.EndsWith("Attribute") && name.Length > "Attribute".Length) {
 
803
                                                name = name.Substring(0, name.Length - "Attribute".Length);
 
804
                                        }
 
805
                                        return name;
 
806
                                });
 
807
 
 
808
                                var result = new TypeCompletionData (type, ext,
 
809
                                        displayText, 
 
810
                                        type.GetStockIcon ());
 
811
                                return result;
 
812
                        }
 
813
 
 
814
                        ICompletionData ICompletionDataFactory.CreateMemberCompletionData(IType type, IEntity member)
 
815
                        {
 
816
                                Lazy<string> displayText = new Lazy<string> (delegate {
 
817
                                        string name = builder.ConvertType(type).ToString(); 
 
818
                                        return name + "."+ member.Name;
 
819
                                });
 
820
 
 
821
                                var result = new LazyGenericTooltipCompletionData (
 
822
                                        (List, sw) => new TooltipInformation (), 
 
823
                                        displayText, 
 
824
                                        member.GetStockIcon ());
 
825
                                return result;
 
826
                        }
 
827
 
 
828
 
 
829
                        ICompletionData ICompletionDataFactory.CreateLiteralCompletionData (string title, string description, string insertText)
 
830
                        {
 
831
                                return new GenericTooltipCompletionData ((list, smartWrap) => {
 
832
                                        var sig = new SignatureMarkupCreator (list.Resolver, ext.FormattingPolicy.CreateOptions ());
 
833
                                        sig.BreakLineAfterReturnType = smartWrap;
 
834
                                        return sig.GetKeywordTooltip (title, null);
 
835
                                }, title, "md-keyword", description, insertText ?? title);
 
836
                        }
 
837
 
 
838
                        ICompletionData ICompletionDataFactory.CreateNamespaceCompletionData (INamespace name)
 
839
                        {
 
840
                                return new CompletionData (name.Name, AstStockIcons.Namespace);
 
841
                        }
 
842
 
 
843
                        ICompletionData ICompletionDataFactory.CreateVariableCompletionData (IVariable variable)
 
844
                        {
 
845
                                return new VariableCompletionData (ext, variable);
 
846
                        }
 
847
 
 
848
                        ICompletionData ICompletionDataFactory.CreateVariableCompletionData (ITypeParameter parameter)
 
849
                        {
 
850
                                return new CompletionData (parameter.Name, parameter.GetStockIcon ());
 
851
                        }
 
852
 
 
853
                        ICompletionData ICompletionDataFactory.CreateEventCreationCompletionData (string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
 
854
                        {
 
855
                                return new EventCreationCompletionData (ext, varName, delegateType, evt, parameterDefinition, currentMember, currentType);
 
856
                        }
 
857
                        
 
858
                        ICompletionData ICompletionDataFactory.CreateNewOverrideCompletionData (int declarationBegin, IUnresolvedTypeDefinition type, IMember m)
 
859
                        {
 
860
                                return new NewOverrideCompletionData (ext, declarationBegin, type, m);
 
861
                        }
 
862
                        ICompletionData ICompletionDataFactory.CreateNewPartialCompletionData (int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember m)
 
863
                        {
 
864
                                var ctx = ext.CSharpUnresolvedFile.GetTypeResolveContext (ext.UnresolvedFileCompilation, ext.document.Editor.Caret.Location);
 
865
                                return new NewOverrideCompletionData (ext, declarationBegin, type, m.CreateResolved (ctx));
 
866
                        }
 
867
                        IEnumerable<ICompletionData> ICompletionDataFactory.CreateCodeTemplateCompletionData ()
 
868
                        {
 
869
                                var result = new CompletionDataList ();
 
870
                                CodeTemplateService.AddCompletionDataForMime ("text/x-csharp", result);
 
871
                                return result;
 
872
                        }
 
873
                        
 
874
                        IEnumerable<ICompletionData> ICompletionDataFactory.CreatePreProcessorDefinesCompletionData ()
 
875
                        {
 
876
                                var project = ext.document.Project;
 
877
                                if (project == null)
 
878
                                        yield break;
 
879
                                var configuration = project.GetConfiguration (MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration;
 
880
                                var par = configuration != null ? configuration.CompilationParameters as CSharpCompilerParameters : null;
 
881
                                if (par == null)
 
882
                                        yield break;
 
883
                                foreach (var define in par.DefineSymbols.Split (';', ',', ' ', '\t').Where (s => !string.IsNullOrWhiteSpace (s)))
 
884
                                        yield return new CompletionData (define, "md-keyword");
 
885
                                        
 
886
                        }
 
887
 
 
888
                        ICompletionData ICompletionDataFactory.CreateImportCompletionData(IType type, bool useFullName)
 
889
                        {
 
890
                                // atm only used in #develop
 
891
                                throw new NotImplementedException ();
 
892
                        }
 
893
 
587
894
                }
588
895
                #endregion
589
896
 
593
900
                        return new ConstructorParameterDataProvider (startOffset, this, type);
594
901
                }
595
902
 
 
903
                IParameterDataProvider IParameterCompletionDataFactory.CreateConstructorProvider (int startOffset, IType type, AstNode initializer)
 
904
                {
 
905
                        return new ConstructorParameterDataProvider (startOffset, this, type, initializer);
 
906
                }
 
907
 
596
908
                IParameterDataProvider IParameterCompletionDataFactory.CreateMethodDataProvider (int startOffset, IEnumerable<IMethod> methods)
597
909
                {
598
910
                        return new MethodParameterDataProvider (startOffset, this, methods);
603
915
                        return new DelegateDataProvider (startOffset, this, type);
604
916
                }
605
917
                
606
 
                IParameterDataProvider IParameterCompletionDataFactory.CreateIndexerParameterDataProvider (int startOffset, IType type, AstNode resolvedNode)
 
918
                IParameterDataProvider IParameterCompletionDataFactory.CreateIndexerParameterDataProvider (int startOffset, IType type, IEnumerable<IProperty> indexers, AstNode resolvedNode)
607
919
                {
608
 
                        return new IndexerParameterDataProvider (startOffset, this, type, resolvedNode);
 
920
                        if (type is ArrayType)
 
921
                                return new ArrayTypeParameterDataProvider (startOffset, this, (ArrayType)type, resolvedNode);
 
922
                        return new IndexerParameterDataProvider (startOffset, this, type, indexers, resolvedNode);
609
923
                }
610
924
                
611
925
                IParameterDataProvider IParameterCompletionDataFactory.CreateTypeParameterDataProvider (int startOffset, IEnumerable<IType> types)
612
926
                {
613
 
                        return new TemplateParameterDataProvider (startOffset, this, types);
 
927
                        return new TypeParameterDataProvider (startOffset, this, types);
 
928
                }
 
929
 
 
930
                IParameterDataProvider IParameterCompletionDataFactory.CreateTypeParameterDataProvider (int startOffset, IEnumerable<IMethod> methods)
 
931
                {
 
932
                        return new TypeParameterDataProvider (startOffset, this, methods);
614
933
                }
615
934
                #endregion
616
935
                
631
950
                        }
632
951
                }
633
952
                
634
 
                internal class TypeSystemSegmentTree : SegmentTree<TypeSystemTreeSegment>, IMemberProvider
 
953
                internal class TypeSystemSegmentTree : SegmentTree<TypeSystemTreeSegment>, ICompletionContextProvider
635
954
                {
 
955
                        MonoDevelop.Ide.Gui.Document document;
 
956
 
 
957
                        public TypeSystemSegmentTree (MonoDevelop.Ide.Gui.Document document)
 
958
                        {
 
959
                                this.document = document;
 
960
                        }
 
961
 
636
962
                        public IUnresolvedTypeDefinition GetTypeAt (int offset)
637
963
                        {
638
964
                                IUnresolvedTypeDefinition result = null;
664
990
                        
665
991
                        internal static TypeSystemSegmentTree Create (MonoDevelop.Ide.Gui.Document document)
666
992
                        {
667
 
                                TypeSystemSegmentTree result = new TypeSystemSegmentTree ();
 
993
                                TypeSystemSegmentTree result = new TypeSystemSegmentTree (document);
668
994
                                
669
995
                                foreach (var type in document.ParsedDocument.TopLevelTypeDefinitions)
670
996
                                        AddType (document, result, type);
675
1001
                        static void AddType (MonoDevelop.Ide.Gui.Document document, TypeSystemSegmentTree result, IUnresolvedTypeDefinition type)
676
1002
                        {
677
1003
                                int offset = document.Editor.LocationToOffset (type.Region.Begin);
678
 
                                int endOffset = document.Editor.LocationToOffset (type.Region.End);
 
1004
                                int endOffset = type.Region.End.IsEmpty ? int.MaxValue : document.Editor.LocationToOffset (type.Region.End);
 
1005
                                if (endOffset < 0)
 
1006
                                        endOffset = int.MaxValue;
679
1007
                                result.Add (new TypeSystemTreeSegment (offset, endOffset - offset, type));
680
1008
                                foreach (var entity in type.Members) {
681
1009
                                        offset = document.Editor.LocationToOffset (entity.Region.Begin);
682
1010
                                        endOffset = document.Editor.LocationToOffset (entity.Region.End);
 
1011
                                        if (endOffset < 0)
 
1012
                                                endOffset = int.MaxValue;
683
1013
                                        result.Add (new TypeSystemTreeSegment (offset, endOffset - offset, entity));
684
1014
                                }
685
1015
                                
687
1017
                                        AddType (document, result, nested);
688
1018
                        }
689
1019
 
690
 
                        void IMemberProvider.GetCurrentMembers (int offset, out IUnresolvedTypeDefinition currentType, out IUnresolvedMember currentMember)
 
1020
                        #region ICompletionContextProvider implementation
 
1021
 
 
1022
                        IList<string> ICompletionContextProvider.ConditionalSymbols {
 
1023
                                get {
 
1024
                                        return document.ParsedDocument.GetAst<SyntaxTree> ().ConditionalSymbols;
 
1025
                                }
 
1026
                        }
 
1027
 
 
1028
                        void ICompletionContextProvider.GetCurrentMembers (int offset, out IUnresolvedTypeDefinition currentType, out IUnresolvedMember currentMember)
691
1029
                        {
692
1030
                                currentType = GetTypeAt (offset);
693
1031
                                currentMember = GetMemberAt (offset);
694
1032
                        }
 
1033
 
 
1034
                        Tuple<string, TextLocation> ICompletionContextProvider.GetMemberTextToCaret (int caretOffset, IUnresolvedTypeDefinition currentType, IUnresolvedMember currentMember)
 
1035
                        {
 
1036
                                int startOffset;
 
1037
                                if (currentMember != null && currentType != null && currentType.Kind != TypeKind.Enum) {
 
1038
                                        startOffset = document.Editor.LocationToOffset(currentMember.Region.Begin);
 
1039
                                } else if (currentType != null) {
 
1040
                                        startOffset = document.Editor.LocationToOffset(currentType.Region.Begin);
 
1041
                                } else {
 
1042
                                        startOffset = 0;
 
1043
                                }
 
1044
                                while (startOffset > 0) {
 
1045
                                        char ch = document.Editor.GetCharAt(startOffset - 1);
 
1046
                                        if (ch != ' ' && ch != '\t') {
 
1047
                                                break;
 
1048
                                        }
 
1049
                                        --startOffset;
 
1050
                                }
 
1051
 
 
1052
                                return Tuple.Create (caretOffset > startOffset ? document.Editor.GetTextAt (startOffset, caretOffset - startOffset) : "", 
 
1053
                                                     (TextLocation)document.Editor.OffsetToLocation (startOffset));
 
1054
                        }
 
1055
 
 
1056
 
 
1057
                        CSharpAstResolver ICompletionContextProvider.GetResolver (CSharpResolver resolver, AstNode rootNode)
 
1058
                        {
 
1059
                                return new CSharpAstResolver (resolver, rootNode, document.ParsedDocument.ParsedFile as CSharpUnresolvedFile);
 
1060
                        }
 
1061
                        #endregion
695
1062
                }
696
1063
                
697
1064
                public IUnresolvedTypeDefinition GetTypeAt (int offset)