public static Task <TooltipInformation> CreateTooltipInformation(CancellationToken ctoken, MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext ctx, ISymbol entity, bool smartWrap, bool createFooter = false, SemanticModel model = null)
{
if (entity == null)
{
return(TaskUtil.Default <TooltipInformation> ());
}
var tooltipInfo = new TooltipInformation();
var sig = new SignatureMarkupCreator(ctx, editor != null ? editor.CaretOffset : 0);
sig.SemanticModel = model;
sig.BreakLineAfterReturnType = smartWrap;
return(Task.Run(() => {
if (ctoken.IsCancellationRequested)
{
return null;
}
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(entity);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + entity, e);
return new TooltipInformation();
}
if (ctoken.IsCancellationRequested)
{
return null;
}
tooltipInfo.SummaryMarkup = Ambience.GetSummaryMarkup(entity) ?? "";
if (entity is IMethodSymbol)
{
var method = (IMethodSymbol)entity;
if (method.IsExtensionMethod)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.ContainingType.Name);
}
}
if (createFooter)
{
tooltipInfo.FooterMarkup = sig.CreateFooter(entity);
}
return tooltipInfo;
}));
}
async void ShowTooltip()
{
var currentSelectedItem = selectedItem;
if (currentSelectedItem == null || currentSelectedItem.DataSource == null)
{
HideTooltip();
return;
}
var i = currentSelectedItem.Item;
if (i < 0 || i >= currentSelectedItem.DataSource.Count)
{
return;
}
if (tooltipSrc != null)
{
tooltipSrc.Cancel();
}
tooltipSrc = new CancellationTokenSource();
var token = tooltipSrc.Token;
try {
currentTooltip = await currentSelectedItem.DataSource [i].GetTooltipInformation(token);
} catch (OperationCanceledException) {
HideTooltip();
return;
} catch (Exception e) {
LoggingService.LogError("Error while creating search popup window tooltip", e);
HideTooltip();
return;
}
if (currentTooltip == null || string.IsNullOrEmpty(currentTooltip.SignatureMarkup) || token.IsCancellationRequested)
{
HideTooltip();
return;
}
declarationviewwindow.Clear();
declarationviewwindow.AddOverload(currentTooltip);
declarationviewwindow.CurrentOverload = 0;
declarationviewwindow.ShowArrow = true;
var rect = SelectedItemRectangle;
declarationviewwindow.ShowPopup(this, new Gdk.Rectangle(0, (int)rect.Y - 5, Allocation.Width, (int)rect.Height), PopupPosition.Right);
}
public static TooltipInformation Generate(DelegateDeclaration dd, int currentParam = -1)
{
var sb = new StringBuilder("<i>(Delegate)</i> ");
if (dd.ReturnType != null)
{
sb.Append(dd.ReturnType.ToString(true)).Append(' ');
}
if (dd.IsFunction)
{
sb.Append("function");
}
else
{
sb.Append("delegate");
}
sb.Append('(');
if (dd.Parameters != null && dd.Parameters.Count != 0)
{
for (int i = 0; i < dd.Parameters.Count; i++)
{
var p = dd.Parameters[i] as DNode;
if (i == currentParam)
{
sb.Append("<u>");
sb.Append(p.ToString(false));
sb.Append("</u>,");
}
else
{
sb.Append(p.ToString(false)).Append(',');
}
}
sb.Remove(sb.Length - 1, 1);
}
sb.Append(')');
var tti = new TooltipInformation();
tti.SignatureMarkup = sb.ToString();
return(tti);
}
static Window CreateItemWindow(InfoItem infoItem)
{
TooltipInformation ti = null;
ti = CreateTooltipInformation(infoItem.Doc, infoItem.Info, infoItem.ResolveResult);
if (ti == null)
{
return(null);
}
var window = new TooltipInformationWindow();
window.AddOverload(ti);
window.ShowArrow = true;
window.RepositionWindow();
return(window);
}
//TODO: Für semantisches Highlighting den TypeRefFinder benutzen und einfach pauschal alle Ids entsprechend highlighten
public static TooltipInformation Create(AbstractType t, ColorScheme st, bool templateParamCompletion = false, int currentMethodParam = -1)
{
var markupGen = new TooltipMarkupGen(st);
var tti = new TooltipInformation {
SignatureMarkup = markupGen.GenTooltipSignature(t, templateParamCompletion, currentMethodParam)
};
var ds = t as DSymbol;
DNode n;
if (ds != null && (n = ds.Definition) != null)
{
CreateTooltipBody(markupGen, n, tti);
}
return(tti);
}
private async Task UpdateDescription()
{
if (descriptionWindow != null)
{
descriptionWindow.Destroy();
descriptionWindow = null;
}
descriptionCts.Cancel();
if (SelectedItemIndex == -1)
{
return;
}
var completionItem = SelectedItem;
descriptionCts = new CancellationTokenSource();
var token = descriptionCts.Token;
TooltipInformation description = null;
try {
var document = _subjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChangesSafe();
description = await RoslynCompletionData.CreateTooltipInformation(document, completionItem, false, token);
} catch {
}
if (token.IsCancellationRequested)
{
return;
}
if (descriptionWindow != null)
{
descriptionWindow.Destroy();
descriptionWindow = null;
}
if (description == null)
{
return;
}
var window = new TooltipInformationWindow();
window.AddOverload(description);
descriptionWindow = window;
ShowDescription();
}
void ShowDescription(TooltipInformation description)
{
HideDescription();
if (description == null)
{
return;
}
var window = new TooltipInformationWindow();
window.AddOverload(description);
descriptionWindow = window;
var rect = GetRowArea(SelectedItemIndex);
int y = rect.Y + Theme.Padding - (int)vadj.Value;
descriptionWindow.ShowPopup(this, new Gdk.Rectangle(0, Math.Min(Allocation.Height, Math.Max(0, y)), Allocation.Width, rect.Height), PopupPosition.Left);
descriptionWindow.Show();
}
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, CSharpResolver resolver, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IEntity entity, bool smartWrap, bool createFooter = false)
{
var tooltipInfo = new TooltipInformation();
if (resolver == null)
{
resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation);
}
var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions());
sig.BreakLineAfterReturnType = smartWrap;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(entity);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + entity, e);
return(new TooltipInformation());
}
tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? "";
if (entity is IMember)
{
var evt = (IMember)entity;
if (evt.ReturnType.Kind == TypeKind.Delegate)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(evt.ReturnType));
}
}
if (entity is IMethod)
{
var method = (IMethod)entity;
if (method.IsExtensionMethod)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName);
}
}
if (createFooter)
{
tooltipInfo.FooterMarkup = sig.CreateFooter(entity);
}
return(tooltipInfo);
}
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IType type, bool smartWrap, bool createFooter = false)
{
var tooltipInfo = new TooltipInformation();
if (type.Kind == TypeKind.Unknown)
{
return(tooltipInfo);
}
var resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation);
var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions());
sig.BreakLineAfterReturnType = smartWrap;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(type.IsParameterized ? type.GetDefinition() : type);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + type, e);
return(new TooltipInformation());
}
if (type.IsParameterized)
{
var typeInfo = new StringBuilder();
for (int i = 0; i < type.TypeParameterCount; i++)
{
typeInfo.AppendLine(type.GetDefinition().TypeParameters [i].Name + " is " + sig.GetTypeReferenceString(type.TypeArguments [i]));
}
tooltipInfo.AddCategory("Type Parameters", typeInfo.ToString());
}
var def = type.GetDefinition();
if (def != null)
{
if (createFooter)
{
tooltipInfo.FooterMarkup = sig.CreateFooter(def);
}
tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(def) ?? "";
}
return(tooltipInfo);
}
public override TooltipInformation CreateTooltipInformation(int overload, int currentParameter, bool smartWrap)
{
var info = new TooltipInformation();
string[] args = Overloads[overload].Split(",".ToCharArray());
string markup = "";
string comma = "";
int current = 1;
foreach (string arg in args)
{
markup += current == currentParameter?string.Format("{0}<b><i>{1}</i></b>", comma, arg) : string.Format("{0}{1}", comma, arg);
comma = ", ";
current++;
}
info.SignatureMarkup = FuncName + "(" + FuncArgs + ")";
info.AddCategory("Parameters", string.Format("{0}( {1} )", FuncName, markup));
return(info);
//return base.CreateTooltipInformation(overload, currentParameter, smartWrap);
}
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, CSharpResolver resolver, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IEntity entity, bool smartWrap, bool createFooter = false)
{
var tooltipInfo = new TooltipInformation();
if (resolver == null)
{
resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation);
}
var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions());
sig.BreakLineAfterReturnType = smartWrap;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(entity);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + entity, e);
return(new TooltipInformation());
}
tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? "";
if (entity is IMember)
{
var evt = (IMember)entity;
if (evt.ReturnType.Kind == TypeKind.Delegate)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(evt.ReturnType));
}
}
if (entity is IMethod)
{
var method = (IMethod)entity;
if (method.IsExtensionMethod)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName);
}
}
if (createFooter)
{
if (entity is IType)
{
var type = entity as IType;
var def = type.GetDefinition();
if (def != null)
{
if (!string.IsNullOrEmpty(def.ParentAssembly.AssemblyName))
{
var project = def.GetSourceProject();
if (project != null)
{
var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, def.Region.FileName);
tooltipInfo.FooterMarkup = "<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(def.ParentAssembly.AssemblyName)) + "</small>" + Environment.NewLine +
"<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), def.Region.Begin.Line) + "</small>";
}
}
}
}
else if (entity.DeclaringTypeDefinition != null)
{
var project = entity.DeclaringTypeDefinition.GetSourceProject();
if (project != null)
{
var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, entity.Region.FileName);
tooltipInfo.FooterMarkup =
"<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(project.Name)) + "</small>" + Environment.NewLine +
"<small>" + GettextCatalog.GetString("From:\t{0}", AmbienceService.EscapeText(entity.DeclaringType.FullName)) + "</small>" + Environment.NewLine +
"<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), entity.Region.Begin.Line) + "</small>";
}
}
}
return(tooltipInfo);
}
internal static Task <TooltipInformation> CreateTooltipInformation(MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext ctx, ISymbol sym, int currentParameter, bool smartWrap, CancellationToken cancelToken)
{
var tooltipInfo = new TooltipInformation();
var sig = new SignatureMarkupCreator(ctx, editor != null ? editor.CaretOffset : 0);
sig.HighlightParameter = currentParameter;
sig.BreakLineAfterReturnType = smartWrap;
return(Task.Run(() => {
if (cancelToken.IsCancellationRequested)
{
return null;
}
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(sym);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + sym, e);
return new TooltipInformation();
}
tooltipInfo.SummaryMarkup = Ambience.GetSummaryMarkup(sym) ?? "";
if (cancelToken.IsCancellationRequested)
{
return null;
}
if (sym is IMethodSymbol)
{
var method = (IMethodSymbol)sym;
if (method.IsExtensionMethod && method.ReducedFrom != null && method.ReducedFrom.ContainingType != null)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.ReducedFrom.ContainingType.Name);
}
}
int paramIndex = currentParameter;
// if (Symbol is IMethodSymbol && ((IMethodSymbol)Symbol).IsExtensionMethod)
// paramIndex++;
var list = GetParameterList(sym);
paramIndex = Math.Min(list.Length - 1, paramIndex);
var curParameter = paramIndex >= 0 && paramIndex < list.Length ? list [paramIndex] : null;
if (curParameter != null)
{
string docText = Ambience.GetDocumentation(sym);
if (!string.IsNullOrEmpty(docText))
{
string text = docText;
Regex paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match match = paramRegex.Match(docText);
if (match.Success)
{
text = Ambience.GetDocumentationMarkup(sym, match.Groups [1].Value);
if (!string.IsNullOrWhiteSpace(text))
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Parameter"), text);
}
}
}
if (curParameter.Type.TypeKind == TypeKind.Delegate)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(curParameter.Type));
}
}
return tooltipInfo;
}));
}
public static async Task <TooltipInformation> GetQuickInfoAsync(int caretOffset, EditorTheme theme, DocumentContext ctx, ISymbol symbol, CancellationToken cancellationToken = default(CancellationToken))
{
var tooltipInfo = new TooltipInformation();
var model = await ctx.AnalysisDocument.GetSemanticModelAsync();
var descriptionService = ctx.RoslynWorkspace.Services.GetLanguageServices(model.Language).GetService <ISymbolDisplayService> ();
var sections = await descriptionService.ToDescriptionGroupsAsync(ctx.RoslynWorkspace, model, caretOffset, new [] { symbol }.AsImmutable(), default(CancellationToken)).ConfigureAwait(false);
ImmutableArray <TaggedText> parts;
var sb = StringBuilderCache.Allocate();
if (sections.TryGetValue(SymbolDescriptionGroups.MainDescription, out parts))
{
TaggedTextUtil.AppendTaggedText(sb, theme, parts);
}
// if generating quick info for an attribute, bind to the class instead of the constructor
if (symbol.ContainingType?.IsAttribute() == true)
{
symbol = symbol.ContainingType;
}
var formatter = ctx.RoslynWorkspace.Services.GetLanguageServices(model.Language).GetService <IDocumentationCommentFormattingService> ();
var documentation = symbol.GetDocumentationParts(model, caretOffset, formatter, cancellationToken);
sb.Append("<span font='" + FontService.SansFontName + "' size='small'>");
if (documentation != null && documentation.Any())
{
sb.AppendLine();
sb.AppendLine();
TaggedTextUtil.AppendTaggedText(sb, theme, documentation);
}
if (sections.TryGetValue(SymbolDescriptionGroups.AnonymousTypes, out parts))
{
if (!parts.IsDefaultOrEmpty)
{
sb.AppendLine();
TaggedTextUtil.AppendTaggedText(sb, theme, parts);
}
}
if (sections.TryGetValue(SymbolDescriptionGroups.AwaitableUsageText, out parts))
{
if (!parts.IsDefaultOrEmpty)
{
sb.AppendLine();
TaggedTextUtil.AppendTaggedText(sb, theme, parts);
}
}
if (sections.TryGetValue(SymbolDescriptionGroups.Exceptions, out parts))
{
if (!parts.IsDefaultOrEmpty)
{
sb.AppendLine();
TaggedTextUtil.AppendTaggedText(sb, theme, parts);
}
}
sb.Append("</span>");
tooltipInfo.SignatureMarkup = StringBuilderCache.ReturnAndFree(sb);
return(tooltipInfo);
}
public static TooltipInformation Generate(DMethod dm, bool isTemplateParamInsight = false, int currentParam = -1)
{
var tti = new TooltipInformation();
var sb = new StringBuilder("<i>(");
string name;
switch (dm.SpecialType)
{
case DMethod.MethodType.Constructor:
sb.Append("Constructor");
name = dm.Parent.Name;
break;
case DMethod.MethodType.Destructor:
sb.Append("Destructor"); name = dm.Parent.Name;
break;
case DMethod.MethodType.Allocator:
sb.Append("Allocator"); name = dm.Parent.Name;
break;
default:
sb.Append("Method");
name = dm.Name;
break;
}
sb.Append(")</i> ");
if (dm.Type != null)
{
sb.Append(dm.Type.ToString(true));
sb.Append(" ");
}
else if (dm.Attributes != null && dm.Attributes.Count != 0)
{
foreach (var attr in dm.Attributes)
{
var m = attr as Modifier;
if (m != null && DTokens.StorageClass[m.Token])
{
sb.Append(DTokens.GetTokenString(m.Token));
sb.Append(" ");
break;
}
}
}
sb.Append(name);
/*TODO: Show attributes?
* if (dm.Attributes != null && dm.Attributes.Count > 0)
* s = dm.AttributeString + ' ';
*/
// Template parameters
if (dm.TemplateParameters != null && dm.TemplateParameters.Length > 0)
{
sb.Append("(");
for (int i = 0; i < dm.TemplateParameters.Length; i++)
{
var p = dm.TemplateParameters[i];
if (isTemplateParamInsight && i == currentParam)
{
sb.Append("<u>");
tti.AddCategory(p.Name, p.ToString());
sb.Append(p.ToString());
sb.Append("</u>");
}
else
{
sb.Append(p.ToString());
}
if (i < dm.TemplateParameters.Length - 1)
{
sb.Append(",");
}
}
sb.Append(")");
}
// Parameters
sb.Append("(");
for (int i = 0; i < dm.Parameters.Count; i++)
{
var p = dm.Parameters[i] as DNode;
if (!isTemplateParamInsight && i == currentParam)
{
sb.Append("<u>");
if (!string.IsNullOrEmpty(p.Description))
{
tti.AddCategory(p.Name, p.Description);
}
sb.Append(p.ToString(true, false));
sb.Append("</u>");
}
else
{
sb.Append(p.ToString(true, false));
}
if (i < dm.Parameters.Count - 1)
{
sb.Append(",");
}
}
sb.Append(")");
tti.SignatureMarkup = sb.ToString();
tti.SummaryMarkup = dm.Description;
tti.FooterMarkup = dm.ToString();
return(tti);
}
static bool CreatePackageTooltipInfo(string name, Task <IReadOnlyList <IPackageInfo> > info, out TooltipInformation ti)
{
switch (info.Status)
{
case TaskStatus.Faulted:
ti = new TooltipInformation {
SignatureMarkup = $"{name}",
SummaryMarkup = "<span color='#ff0000'><i>Could not load package information</i></span>"
};
return(true);
case TaskStatus.RanToCompletion:
ti = PackageSearchHelpers.CreateTooltipInformation(info.Result);
return(true);
case TaskStatus.Canceled:
ti = null;
return(true);
default:
ti = new TooltipInformation {
SignatureMarkup = $"{name}",
SummaryMarkup = "<i>Loading...</i>"
};
return(false);
}
}
public override TooltipInformation CreateTooltipInformation(bool smartWrap)
{
var tti = new TooltipInformation();
var n = Node;
var dn = n as DNode;
var sb = new StringBuilder();
sb.Append("<i>(");
if (dn is DClassLike)
{
switch ((dn as DClassLike).ClassType)
{
case DTokens.Class:
sb.Append("Class");
break;
case DTokens.Template:
if (dn.ContainsAttribute(DTokens.Mixin))
{
sb.Append("Mixin ");
}
sb.Append("Template");
break;
case DTokens.Struct:
sb.Append("Struct");
break;
case DTokens.Union:
sb.Append("Union");
break;
}
}
else if (dn is DEnum)
{
sb.Append("Enum");
}
else if (dn is DEnumValue)
{
sb.Append("Enum Value");
}
else if (dn is DVariable)
{
if (dn.Parent is DMethod)
{
var dm = dn.Parent as DMethod;
if (dm.Parameters.Contains(dn))
{
sb.Append("Parameters");
}
else
{
sb.Append("Local");
}
}
else if (dn.Parent is DClassLike)
{
sb.Append("Field");
}
else
{
sb.Append("Variable");
}
}
else if (dn is DMethod)
{
sb.Append("Method");
}
else if (dn is TemplateParameter.Node)
{
sb.Append("Template Parameter");
}
sb.Append(")</i> ");
tti.SignatureMarkup = sb.Append(AmbienceService.EscapeText(PureNodeString)).ToString();
if (!string.IsNullOrWhiteSpace(n.Description))
{
tti.SummaryMarkup = AmbienceService.EscapeText(n.Description);
}
return(tti);
}
TooltipInformation CreateTooltip(ToolTipData data, int offset, Ambience ambience, Gdk.ModifierType modifierState)
{
ResolveResult result = data.Result;
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null)
{
return(null);
}
bool createFooter = (modifierState & Gdk.ModifierType.Mod1Mask) != 0;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (file == null)
{
return(null);
}
try {
if (result is AliasNamespaceResolveResult)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetAliasedNamespaceTooltip((AliasNamespaceResolveResult)result));
}
if (result is AliasTypeResolveResult)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetAliasedTypeTooltip((AliasTypeResolveResult)result));
}
if (data.Node is TypeOfExpression)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetTypeOfTooltip((TypeOfExpression)data.Node, result as TypeOfResolveResult));
}
if (data.Node is PrimitiveType && data.Node.Parent is Constraint)
{
var t = (PrimitiveType)data.Node;
if (t.Keyword == "class" || t.Keyword == "new" || t.Keyword == "struct")
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetConstraintTooltip(t.Keyword));
}
return(null);
}
if (data.Node is ExternAliasDeclaration)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetExternAliasTooltip((ExternAliasDeclaration)data.Node, doc.Project as DotNetProject));
}
if (result == null && data.Node is CSharpTokenNode)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip(data.Node));
}
if (data.Node is PrimitiveType && ((PrimitiveType)data.Node).KnownTypeCode == KnownTypeCode.Void)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip("void", null));
}
if (data.Node is NullReferenceExpression)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip("null", null));
}
if (result is UnknownIdentifierResolveResult)
{
return(new TooltipInformation()
{
SignatureMarkup = string.Format("error CS0103: The name `{0}' does not exist in the current context", ((UnknownIdentifierResolveResult)result).Identifier)
});
}
else if (result is UnknownMemberResolveResult)
{
var ur = (UnknownMemberResolveResult)result;
if (ur.TargetType.Kind != TypeKind.Unknown)
{
return(new TooltipInformation()
{
SignatureMarkup = string.Format("error CS0117: `{0}' does not contain a definition for `{1}'", ur.TargetType.FullName, ur.MemberName)
});
}
}
else if (result.IsError)
{
return(new TooltipInformation()
{
SignatureMarkup = "Unknown resolve error."
});
}
if (result is LocalResolveResult)
{
var lr = (LocalResolveResult)result;
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
tooltipInfo.SignatureMarkup = sig.GetLocalVariableMarkup(lr.Variable);
return(tooltipInfo);
}
else if (result is MethodGroupResolveResult)
{
var mrr = (MethodGroupResolveResult)result;
var allMethods = new List <IMethod> (mrr.Methods);
foreach (var l in mrr.GetExtensionMethods())
{
allMethods.AddRange(l);
}
var method = allMethods.FirstOrDefault();
if (method != null)
{
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
method,
false,
createFooter));
}
}
else if (result is CSharpInvocationResolveResult)
{
var invocationResult = (CSharpInvocationResolveResult)result;
var member = (IMember)invocationResult.ReducedMethod ?? invocationResult.Member;
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
member,
false,
createFooter));
}
else if (result is MemberResolveResult)
{
var member = ((MemberResolveResult)result).Member;
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
member,
false,
createFooter));
}
else if (result is NamespaceResolveResult)
{
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(((NamespaceResolveResult)result).Namespace);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + ((NamespaceResolveResult)result).Namespace, e);
return(new TooltipInformation());
}
return(tooltipInfo);
}
else if (result is OperatorResolveResult)
{
var or = result as OperatorResolveResult;
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(or.UserDefinedOperatorMethod);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + ((NamespaceResolveResult)result).Namespace, e);
return(new TooltipInformation());
}
return(tooltipInfo);
}
else
{
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
result.Type,
false,
createFooter));
}
} catch (Exception e) {
LoggingService.LogError("Error while creating tooltip.", e);
return(null);
}
return(null);
}
public override TooltipInformation CreateTooltipInformation(bool smartWrap)
{
var tooltipInfo = new TooltipInformation();
return(tooltipInfo);
}
