← 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.Resolver/TextEditorResolverProvider.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.Resolver/TextEditorResolverProvider.cs
41
41
using ICSharpCode.NRefactory.CSharp.TypeSystem;
42
42
using System.Threading;
43
43
using MonoDevelop.Refactoring;
 
44
using ICSharpCode.NRefactory.CSharp.Refactoring;
44
45
 
45
46
namespace MonoDevelop.CSharp.Resolver
46
47
{
56
57
                        if (doc == null)
57
58
                                return "";
58
59
                        var loc = RefactoringService.GetCorrectResolveLocation (doc, data.OffsetToLocation (offset));
59
 
                        var unit       = doc.ParsedDocument.GetAst<CompilationUnit> ();
60
 
                        var parsedFile = doc.ParsedDocument.ParsedFile as CSharpParsedFile;
 
60
                        var unit = doc.ParsedDocument.GetAst<SyntaxTree> ();
 
61
                        var parsedFile = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
61
62
                        var node       = unit.GetNodeAt<Expression> (loc.Line, loc.Column);
62
63
                        if (unit == null || parsedFile == null || node == null)
63
64
                                return "";
96
97
                        var data = doc.Editor;
97
98
                        var loc = data.OffsetToLocation (offset);
98
99
 
99
 
                        var unit = parsedDocument.GetAst<CompilationUnit> ();
100
 
                        var parsedFile = parsedDocument.ParsedFile as CSharpParsedFile;
 
100
                        var unit = parsedDocument.GetAst<SyntaxTree> ();
 
101
                        var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
101
102
                        
102
103
                        if (unit == null || parsedFile == null) {
103
104
                                return null;
117
118
                static string paramStr = GettextCatalog.GetString ("Parameter");
118
119
                static string localStr = GettextCatalog.GetString ("Local variable");
119
120
                static string methodStr = GettextCatalog.GetString ("Method");
120
 
                
 
121
 
121
122
                static string namespaceStr = GettextCatalog.GetString ("Namespace");            
122
123
                static string GetString (IType type)
123
124
                {
174
175
                                return "'" + obj + "'";
175
176
                        return obj.ToString ();
176
177
                }
177
 
                
178
 
                public string CreateTooltip (IParsedFile unit, ResolveResult result, string errorInformations, Ambience ambience, Gdk.ModifierType modifierState)
179
 
                {
180
 
                        OutputSettings settings = new OutputSettings (OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
181
 
                        //                      if ((Gdk.ModifierType.ShiftMask & modifierState) == Gdk.ModifierType.ShiftMask) {
182
 
                        //                              settings.EmitNameCallback = delegate(object domVisitable, ref string outString) {
183
 
                        //                                      // crop used namespaces.
184
 
                        //                                      if (unit != null) {
185
 
                        //                                              int len = 0;
186
 
                        //                                              foreach (var u in unit.Usings) {
187
 
                        //                                                      foreach (string ns in u.Namespaces) {
188
 
                        //                                                              if (outString.StartsWith (ns + ".")) {
189
 
                        //                                                                      len = Math.Max (len, ns.Length + 1);
190
 
                        //                                                              }
191
 
                        //                                                      }
192
 
                        //                                              }
193
 
                        //                                              string newName = outString.Substring (len);
194
 
                        //                                              int count = 0;
195
 
                        //                                              // check if there is a name clash.
196
 
                        //                                              if (dom.GetType (newName) != null)
197
 
                        //                                                      count++;
198
 
                        //                                              foreach (IUsing u in unit.Usings) {
199
 
                        //                                                      foreach (string ns in u.Namespaces) {
200
 
                        //                                                              if (dom.GetType (ns + "." + newName) != null)
201
 
                        //                                                                      count++;
202
 
                        //                                                      }
203
 
                        //                                              }
204
 
                        //                                              if (len > 0 && count == 1)
205
 
                        //                                                      outString = newName;
206
 
                        //                                      }
207
 
                        //                              };
208
 
                        //                      }
209
 
                        
210
 
                        // Approximate value for usual case
211
 
                        StringBuilder s = new StringBuilder (150);
212
 
                        string doc = null;
213
 
                        if (result != null) {
214
 
                                if (result is UnknownIdentifierResolveResult) {
215
 
                                        s.Append (String.Format (GettextCatalog.GetString ("Unresolved identifier '{0}'"), ((UnknownIdentifierResolveResult)result).Identifier));
216
 
                                } else if (result.IsError) {
217
 
                                        s.Append (GettextCatalog.GetString ("Resolve error."));
218
 
                                } else if (result is LocalResolveResult) {
219
 
                                        var lr = (LocalResolveResult)result;
220
 
                                        s.Append ("<small><i>");
221
 
                                        s.Append (lr.IsParameter ? paramStr : localStr);
222
 
                                        s.Append ("</i></small>\n");
223
 
                                        s.Append (ambience.GetString (lr.Variable.Type, settings));
224
 
                                        s.Append (" ");
225
 
                                        s.Append (lr.Variable.Name);
226
 
                                } else if (result is MethodGroupResolveResult) {
227
 
                                        var mrr = (MethodGroupResolveResult)result;
228
 
                                        s.Append ("<small><i>");
229
 
                                        s.Append (methodStr);
230
 
                                        s.Append ("</i></small>\n");
231
 
                                        var allMethods = new List<IMethod> (mrr.Methods);
232
 
                                        foreach (var l in mrr.GetExtensionMethods ()) {
233
 
                                                allMethods.AddRange (l);
234
 
                                        }
235
 
                                        
236
 
                                        var method = allMethods.FirstOrDefault ();
237
 
                                        if (method != null) {
238
 
                                                s.Append (ambience.GetString (method, settings));
239
 
                                                if (allMethods.Count > 1) {
240
 
                                                        int overloadCount = allMethods.Count - 1;
241
 
                                                        s.Append (string.Format (GettextCatalog.GetPluralString (" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
242
 
                                                }
243
 
                                                doc = AmbienceService.GetDocumentationSummary (method);
244
 
                                        }
245
 
                                } else if (result is MemberResolveResult) {
246
 
                                        var member = ((MemberResolveResult)result).Member;
247
 
                                        s.Append ("<small><i>");
248
 
                                        s.Append (GetString (member));
249
 
                                        s.Append ("</i></small>\n");
250
 
                                        var field = member as IField;
251
 
                                        if (field != null && field.IsConst) {
252
 
                                                s.Append (ambience.GetString (field.Type, settings));
 
178
                static CSharpAmbience ambience = new CSharpAmbience ();
 
179
 
 
180
                static TypeSystemAstBuilder CreateBuilder (MonoDevelop.Ide.Gui.Document doc, int offset, ICompilation compilation)
 
181
                {
 
182
                        var ctx = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
 
183
                        var state = ctx.GetResolver (doc.Compilation, doc.Editor.OffsetToLocation (offset));
 
184
                        var builder = new TypeSystemAstBuilder (state);
 
185
                        builder.AddAnnotations = true;
 
186
                        var dt = state.CurrentTypeDefinition;
 
187
                        var declaring = dt != null ? dt.DeclaringTypeDefinition : null;
 
188
                        if (declaring != null) {
 
189
                                while (dt != null) {
 
190
                                        if (dt.Equals (declaring)) {
 
191
                                                builder.AlwaysUseShortTypeNames = true;
 
192
                                                break;
 
193
                                        }
 
194
                                        dt = dt.DeclaringTypeDefinition;
 
195
                                }
 
196
                        }
 
197
                        return builder;
 
198
                }
 
199
 
 
200
                internal static MonoDevelop.CSharp.Completion.MemberCompletionData.MyAmbience CreateAmbience (Document doc, int offset, ICompilation compilation)
 
201
                {
 
202
                        return new MonoDevelop.CSharp.Completion.MemberCompletionData.MyAmbience (CreateBuilder (doc, offset, compilation));
 
203
                }
 
204
 
 
205
                public string CreateTooltip (MonoDevelop.Ide.Gui.Document doc, int offset, ResolveResult result, string errorInformations, Gdk.ModifierType modifierState)
 
206
                {
 
207
                        try {
 
208
                                OutputSettings settings = new OutputSettings (OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
 
209
                                // Approximate value for usual case
 
210
                                StringBuilder s = new StringBuilder (150);
 
211
                                string documentation = null;
 
212
                                if (result != null) {
 
213
                                        if (result is UnknownIdentifierResolveResult) {
 
214
                                                s.Append (String.Format (GettextCatalog.GetString ("Unresolved identifier '{0}'"), ((UnknownIdentifierResolveResult)result).Identifier));
 
215
                                        } else if (result.IsError) {
 
216
                                                s.Append (GettextCatalog.GetString ("Resolve error."));
 
217
                                        } else if (result is LocalResolveResult) {
 
218
                                                var lr = (LocalResolveResult)result;
 
219
                                                s.Append ("<small><i>");
 
220
                                                s.Append (lr.IsParameter ? paramStr : localStr);
 
221
                                                s.Append ("</i></small>\n");
 
222
                                                s.Append (ambience.GetString (lr.Variable.Type, settings));
253
223
                                                s.Append (" ");
254
 
                                                s.Append (field.Name);
255
 
                                                s.Append (" = ");
256
 
                                                s.Append (GetConst (field.ConstantValue));
257
 
                                                s.Append (";");
 
224
                                                s.Append (lr.Variable.Name);
 
225
                                        } else if (result is MethodGroupResolveResult) {
 
226
                                                var mrr = (MethodGroupResolveResult)result;
 
227
                                                s.Append ("<small><i>");
 
228
                                                s.Append (methodStr);
 
229
                                                s.Append ("</i></small>\n");
 
230
                                                var allMethods = new List<IMethod> (mrr.Methods);
 
231
                                                foreach (var l in mrr.GetExtensionMethods ()) {
 
232
                                                        allMethods.AddRange (l);
 
233
                                                }
 
234
                                                var method = allMethods.FirstOrDefault ();
 
235
                                                if (method != null) {
 
236
                                                        s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, method.Compilation).ConvertEntity (method)));
 
237
                                                        if (allMethods.Count > 1) {
 
238
                                                                int overloadCount = allMethods.Count - 1;
 
239
                                                                s.Append (string.Format (GettextCatalog.GetPluralString (" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
 
240
                                                        }
 
241
                                                        documentation = AmbienceService.GetSummaryMarkup (method);
 
242
                                                }
 
243
                                        } else if (result is MemberResolveResult) {
 
244
                                                var member = ((MemberResolveResult)result).Member;
 
245
                                                s.Append ("<small><i>");
 
246
                                                s.Append (GetString (member));
 
247
                                                s.Append ("</i></small>\n");
 
248
                                                var field = member as IField;
 
249
                                                if (field != null && field.IsConst) {
 
250
                                                        s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, field.Compilation).ConvertType (field.Type)));
 
251
                                                        s.Append (" ");
 
252
                                                        s.Append (field.Name);
 
253
                                                        s.Append (" = ");
 
254
                                                        s.Append (GetConst (field.ConstantValue));
 
255
                                                        s.Append (";");
 
256
                                                } else {
 
257
                                                        s.Append (GLib.Markup.EscapeText (CreateAmbience (doc, offset, member.Compilation).ConvertEntity (member)));
 
258
                                                }
 
259
                                                documentation = AmbienceService.GetSummaryMarkup (member);
 
260
                                        } else if (result is NamespaceResolveResult) {
 
261
                                                s.Append ("<small><i>");
 
262
                                                s.Append (namespaceStr);
 
263
                                                s.Append ("</i></small>\n");
 
264
                                                s.Append (ambience.GetString (((NamespaceResolveResult)result).NamespaceName, settings));
258
265
                                        } else {
259
 
                                                s.Append (ambience.GetString (member, settings));
260
 
                                        }
261
 
                                        doc = AmbienceService.GetDocumentationSummary (member);
262
 
                                } else if (result is NamespaceResolveResult) {
263
 
                                        s.Append ("<small><i>");
264
 
                                        s.Append (namespaceStr);
265
 
                                        s.Append ("</i></small>\n");
266
 
                                        s.Append (ambience.GetString (((NamespaceResolveResult)result).NamespaceName, settings));
267
 
                                } else {
268
 
                                        var tr = result;
269
 
                                        var typeString = GetString (tr.Type);
270
 
                                        if (!string.IsNullOrEmpty (typeString)) {
271
 
                                                s.Append ("<small><i>");
272
 
                                                s.Append (typeString);
273
 
                                                s.Append ("</i></small>\n");
274
 
                                        }
275
 
                                        settings.OutputFlags |= OutputFlags.UseFullName;
276
 
                                        s.Append (ambience.GetString (tr.Type, settings));
277
 
                                        doc = AmbienceService.GetDocumentationSummary (tr.Type.GetDefinition ());
 
266
                                                var tr = result;
 
267
                                                var typeString = GetString (tr.Type);
 
268
                                                if (!string.IsNullOrEmpty (typeString)) {
 
269
                                                        s.Append ("<small><i>");
 
270
                                                        s.Append (typeString);
 
271
                                                        s.Append ("</i></small>\n");
 
272
                                                }
 
273
                                                settings.OutputFlags |= OutputFlags.UseFullName;
 
274
                                                s.Append (ambience.GetString (tr.Type, settings));
 
275
                                                documentation = AmbienceService.GetSummaryMarkup (tr.Type.GetDefinition ());
 
276
                                        }
 
277
                                        
 
278
                                        if (!string.IsNullOrEmpty (documentation)) {
 
279
                                                s.Append ("\n<small>");
 
280
                                                s.Append (documentation);
 
281
                                                s.Append ("</small>");
 
282
                                        }
278
283
                                }
279
284
                                
280
 
                                if (!string.IsNullOrEmpty (doc)) {
281
 
                                        s.Append ("\n<small>");
282
 
                                        s.Append (AmbienceService.GetDocumentationMarkup ("<summary>" + doc + "</summary>"));
 
285
                                if (!string.IsNullOrEmpty (errorInformations)) {
 
286
                                        if (s.Length != 0)
 
287
                                                s.Append ("\n\n");
 
288
                                        s.Append ("<small>");
 
289
                                        s.Append (errorInformations);
283
290
                                        s.Append ("</small>");
284
291
                                }
285
 
                        }
286
 
                        
287
 
                        if (!string.IsNullOrEmpty (errorInformations)) {
288
 
                                if (s.Length != 0)
289
 
                                        s.Append ("\n\n");
290
 
                                s.Append ("<small>");
291
 
                                s.Append (errorInformations);
292
 
                                s.Append ("</small>");
293
 
                        }
294
 
                        return s.ToString ();
 
292
                                return s.ToString ();
 
293
                        } catch (Exception e){
 
294
                                return e.ToString ();
 
295
                        }
295
296
                }
296
297
                
297
298
                #endregion