static StackPanel ShowSymbolLocation(ISymbol symbol, string path)
{
var t = new TextBlock()
.Append("defined in ")
.Append(String.IsNullOrEmpty(path) ? "?" : path, true);
if (symbol.IsMemberOrType() && symbol.ContainingNamespace != null)
{
t.Append("\nnamespace: ").Append(symbol.ContainingNamespace.ToDisplayString());
}
if (symbol.Kind == SymbolKind.Method)
{
var m = (symbol as IMethodSymbol).ReducedFrom;
if (m != null)
{
t.Append("\nclass: ").Append(m.ContainingType.Name);
}
}
return(new StackPanel {
Children =
{
new TextBlock {
HorizontalAlignment = HorizontalAlignment.Stretch, Background = Brushes.Gray, Foreground = Brushes.White
}.Append(symbol.Name, true),
t
}
});
}
public void ShowTypeConstaints(ITypeParameterSymbol typeParameter, TextBlock text)
{
bool hasConstraint = false;
if (typeParameter.HasReferenceTypeConstraint)
{
text.Append(hasConstraint ? ", " : String.Empty).Append("class", Keyword);
hasConstraint = true;
}
if (typeParameter.HasValueTypeConstraint)
{
text.Append(hasConstraint ? ", " : String.Empty).Append("struct", Keyword);
hasConstraint = true;
}
if (typeParameter.HasUnmanagedTypeConstraint)
{
text.Append(hasConstraint ? ", " : String.Empty).Append("unmanaged", Keyword);
hasConstraint = true;
}
if (typeParameter.HasConstructorConstraint)
{
text.Append(hasConstraint ? ", " : String.Empty).Append("new", Keyword).Append("()");
hasConstraint = true;
}
foreach (var constraint in typeParameter.ConstraintTypes)
{
text.Append(hasConstraint ? ", " : String.Empty).AddSymbol(constraint, false, this);
hasConstraint = true;
}
}
void ShowSymbolDeclaration(ISymbol symbol, TextBlock info)
{
if (symbol.IsAbstract)
{
info.Append("abstract ", Keyword);
}
else if (symbol.IsStatic)
{
info.Append("static ", Keyword);
}
else if (symbol.IsVirtual)
{
info.Append("virtual ", Keyword);
}
else if (symbol.IsOverride)
{
info.Append(symbol.IsSealed ? "sealed override " : "override ", Keyword);
ISymbol o = null;
switch (symbol.Kind)
{
case SymbolKind.Method: o = ((IMethodSymbol)symbol).OverriddenMethod; break;
case SymbolKind.Property: o = ((IPropertySymbol)symbol).OverriddenProperty; break;
case SymbolKind.Event: o = ((IEventSymbol)symbol).OverriddenEvent; break;
}
if (o != null)
{
var t = o.ContainingType;
if (t != null && t.IsCommonClass() == false)
{
info.AddSymbol(t, null, this).Append(".").AddSymbol(o, null, this).Append(" ");
}
}
}
else if (symbol.IsSealed && (symbol.Kind == SymbolKind.NamedType && (symbol as INamedTypeSymbol).TypeKind == TypeKind.Class || symbol.Kind == SymbolKind.Method))
{
info.Append("sealed ", Keyword);
}
if (symbol.Kind == SymbolKind.Method)
{
var method = symbol as IMethodSymbol;
if (method.IsAsync)
{
info.Append("async ");
}
if (method.ReturnsByRef)
{
info.Append("ref ");
}
else if (method.ReturnsByRefReadonly)
{
info.Append("ref readonly");
}
}
if (symbol.IsExtern)
{
info.Append("extern ", Keyword);
}
}
private void AppendMoreInfoHyperLink(TextBlock tb, string hlink)
{
tb.Append(new System.Windows.Documents.LineBreak());
System.Windows.Documents.Hyperlink hyperl =
new System.Windows.Documents.Hyperlink(new System.Windows.Documents.Run("More information..."));
hyperl.NavigateUri = new Uri(hlink);
tb.Append(hyperl);
hyperl.RequestNavigate += (sender, args) => System.Diagnostics.Process.Start(args.Uri.AbsoluteUri);
}
void ShowSymbolToolTip(object sender, ToolTipEventArgs e)
{
var title = new TextBlock {
HorizontalAlignment = HorizontalAlignment.Stretch,
Background = WpfBrushes.Gray,
Foreground = WpfBrushes.White,
TextWrapping = TextWrapping.Wrap
}
.Append(_Symbol.GetAccessibility() + _Symbol.GetAbstractionModifier() + _Symbol.GetSymbolKindName() + " ")
.Append(_Symbol.GetSignatureString(), true);
var content = new TextBlock {
TextWrapping = TextWrapping.Wrap
}
.Append("namespace: " + _Symbol.ContainingNamespace?.ToString())
.Append("\nassembly: " + _Symbol.GetAssemblyModuleName());
ITypeSymbol t = _Symbol.ContainingType;
if (t != null)
{
content.Append("\n" + t.GetSymbolKindName() + ": ")
.Append(t.ToDisplayString(QuickInfoSymbolDisplayFormat));
}
;
t = _Symbol.GetReturnType();
if (t != null)
{
content.Append("\nreturn value: ").Append(t.ToDisplayString(QuickInfoSymbolDisplayFormat), true);
}
var f = _Symbol as IFieldSymbol;
if (f != null && f.IsConst)
{
content.Append("\nconst: " + f.ConstantValue.ToString());
}
var panel = new StackPanel {
Children =
{
title,
content
}
};
ToolTip = panel;
ToolTipOpening -= ShowSymbolToolTip;
}
static void ShowDelegateSignature(TextBlock content, INamedTypeSymbol d)
{
content.Append("\nsignature: ");
var invoke = d.OriginalDefinition.DelegateInvokeMethod;
content.AddSymbol(invoke.ReturnType, false, SymbolFormatter.Empty)
.Append(" ").AddSymbol(d, true, SymbolFormatter.Empty)
.AddParameters(invoke.Parameters, SymbolFormatter.Empty);
}
static void ShowDelegateSignature(TextBlock content, INamedTypeSymbol type)
{
content.Append("\n" + R.T_Signature);
var invoke = type.OriginalDefinition.DelegateInvokeMethod;
content.AddSymbol(invoke.ReturnType, false, SymbolFormatter.Instance)
.Append(" ").AddSymbol(type, true, SymbolFormatter.Instance)
.AddParameters(invoke.Parameters, SymbolFormatter.Instance);
}
static void ShowEnumType(TextBlock content, ISymbol symbol)
{
var t = ((INamedTypeSymbol)symbol).EnumUnderlyingType.ToDisplayString(CodeAnalysisHelper.QuickInfoSymbolDisplayFormat);
if (t != "int")
{
content.Append("\n" + R.T_Type + t);
}
}
public TextBlock ShowSymbolDeclaration(ISymbol symbol, TextBlock info, bool defaultPublic, bool hideTypeKind)
{
if (defaultPublic == false || symbol.DeclaredAccessibility != Accessibility.Public)
{
info.Append(symbol.GetAccessibility(), Keyword);
}
if (symbol.Kind == SymbolKind.Field)
{
ShowFieldDeclaration(symbol as IFieldSymbol, info);
}
else
{
ShowSymbolDeclaration(symbol, info);
}
if (hideTypeKind == false)
{
info.Append(symbol.GetSymbolKindName(), symbol.Kind == SymbolKind.NamedType ? Keyword : null).Append(" ");
}
return(info);
}
void ShowLocalDeclaration(ILocalSymbol local, TextBlock info)
{
if (local.IsConst)
{
info.Append("const ", Keyword);
}
else
{
if (local.IsStatic)
{
info.Append("static ", Keyword);
}
if (local.IsRef)
{
info.Append(local.RefKind == RefKind.RefReadOnly ? "ref readonly " : "ref", Keyword);
}
if (local.IsFixed)
{
info.Append("fixed ", Keyword);
}
}
}
void ShowFieldDeclaration(IFieldSymbol field, TextBlock info)
{
if (field.IsConst)
{
info.Append("const ", Keyword);
}
else
{
if (field.IsStatic)
{
info.Append("static ", Keyword);
}
if (field.IsReadOnly)
{
info.Append("readonly ", Keyword);
}
else if (field.IsVolatile)
{
info.Append("volatile ", Keyword);
}
}
}
void ShowToolTip(object sender, ToolTipEventArgs args)
{
var tip = new TextBlock()
.Append(Symbol.GetAccessibility() + Symbol.GetAbstractionModifier() + Symbol.GetSymbolKindName() + " ")
.Append(Symbol.GetSignatureString(), true);
ITypeSymbol t = Symbol.ContainingType;
if (t != null)
{
tip.Append("\n" + t.GetSymbolKindName() + ": ")
.Append(t.ToDisplayString(__MemberNameFormat));
}
t = Symbol.GetReturnType();
if (t != null)
{
tip.Append("\nreturn value: " + t.ToDisplayString(__MemberNameFormat));
}
tip.Append("\nnamespace: " + Symbol.ContainingNamespace?.ToString())
.Append("\nassembly: " + Symbol.GetAssemblyModuleName());
var f = Symbol as IFieldSymbol;
if (f != null && f.IsConst)
{
tip.Append("\nconst: " + f.ConstantValue.ToString());
}
var doc = Symbol.GetXmlDocSummaryForSymbol();
if (doc != null)
{
new XmlDocRenderer((SmartBar as CSharpSmartBar)._SemanticModel.Compilation, __Formatter).Render(doc, tip.Append("\n\n").Inlines);
tip.MaxWidth = Config.Instance.QuickInfoMaxWidth;
}
tip.TextWrapping = TextWrapping.Wrap;
ToolTip = tip;
ToolTipService.SetShowDuration(this, 15000);
ToolTipOpening -= ShowToolTip;
}
void ShowSymbolDeclaration(ISymbol symbol, TextBlock info)
{
if (symbol.IsAbstract)
{
info.Append("abstract ", Keyword);
}
else if (symbol.IsStatic)
{
info.Append("static ", Keyword);
}
else if (symbol.IsVirtual)
{
info.Append("virtual ", Keyword);
}
else if (symbol.IsOverride)
{
info.Append(symbol.IsSealed ? "sealed override " : "override ", Keyword);
ISymbol o = null;
switch (symbol.Kind)
{
case SymbolKind.Method: o = ((IMethodSymbol)symbol).OverriddenMethod; break;
case SymbolKind.Property: o = ((IPropertySymbol)symbol).OverriddenProperty; break;
case SymbolKind.Event: o = ((IEventSymbol)symbol).OverriddenEvent; break;
}
if (o != null)
{
var t = o.ContainingType;
if (t != null && t.IsCommonClass() == false)
{
info.AddSymbol(t, null, this).Append(".").AddSymbol(o, null, this).Append(" ");
}
}
}
else if (symbol.IsSealed && (symbol.Kind == SymbolKind.NamedType && ((INamedTypeSymbol)symbol).TypeKind == TypeKind.Class || symbol.Kind == SymbolKind.Method))
{
info.Append("sealed ", Keyword);
}
if (symbol.Kind == SymbolKind.Method)
{
var m = (symbol as IMethodSymbol).GetSpecialMethodModifier();
if (m != null)
{
info.Append(m, Keyword);
}
}
}
static void AddParameterList(TextBlock t, SyntaxNode node)
{
ParameterListSyntax p = null;
if (node is BaseMethodDeclarationSyntax)
{
p = ((BaseMethodDeclarationSyntax)node).ParameterList;
}
else if (node.IsKind(SyntaxKind.DelegateDeclaration))
{
p = ((DelegateDeclarationSyntax)node).ParameterList;
}
else if (node is OperatorDeclarationSyntax)
{
p = ((OperatorDeclarationSyntax)node).ParameterList;
}
if (p != null)
{
var useParamName = Config.Instance.NaviBarOptions.MatchFlags(NaviBarOptions.ParameterListShowParamName);
t.Append(p.GetParameterListSignature(useParamName), ThemeHelper.SystemGrayTextBrush);
}
}
protected void AppendTextBlock()
{
CurrentTextBlock.Append(CodeBlocks);
}
internal TextBlock Format(TextBlock block, ImmutableArray <SymbolDisplayPart> parts, int argIndex)
{
const SymbolDisplayPartKind ExtensionName = (SymbolDisplayPartKind)29;
foreach (var part in parts)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.AliasName:
//todo resolve alias type
goto default;
case SymbolDisplayPartKind.ClassName:
if (part.Symbol.Kind == SymbolKind.Method)
{
block.AddSymbol(part.Symbol, true, Method);
}
else if ((part.Symbol as INamedTypeSymbol).IsAnonymousType)
{
block.Append("?", Class);
}
else
{
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Class);
}
break;
case SymbolDisplayPartKind.EnumName:
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Enum);
break;
case SymbolDisplayPartKind.InterfaceName:
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Interface);
break;
case SymbolDisplayPartKind.MethodName:
block.AddSymbol(part.Symbol, argIndex != Int32.MinValue, Method);
break;
case SymbolDisplayPartKind.ParameterName:
var p = part.Symbol as IParameterSymbol;
if (p.Ordinal == argIndex || p.IsParams && argIndex > p.Ordinal)
{
block.Append(p.Name, true, true, Parameter);
}
else
{
block.Append(p.Name, false, false, Parameter);
}
break;
case SymbolDisplayPartKind.StructName:
if (part.Symbol.Kind == SymbolKind.Method)
{
block.AddSymbol(part.Symbol, true, Method);
}
else
{
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Struct);
}
break;
case SymbolDisplayPartKind.DelegateName:
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Delegate);
break;
case SymbolDisplayPartKind.StringLiteral:
block.Append(part.ToString(), false, false, Text);
break;
case SymbolDisplayPartKind.Keyword:
block.Append(part.ToString(), false, false, Keyword);
break;
case SymbolDisplayPartKind.NamespaceName:
block.Append(part.Symbol.Name, Namespace);
break;
case SymbolDisplayPartKind.TypeParameterName:
block.Append(part.Symbol.Name, argIndex == Int32.MinValue, false, TypeParameter);
break;
case SymbolDisplayPartKind.FieldName:
block.AddSymbol(part.Symbol, argIndex == Int32.MinValue, Field);
break;
case SymbolDisplayPartKind.PropertyName:
block.Append(part.Symbol.Name, Property);
break;
case SymbolDisplayPartKind.EventName:
block.Append(part.Symbol.Name, Delegate);
break;
case ExtensionName:
block.AddSymbol(part.Symbol, true, Method);
break;
default:
block.Append(part.ToString());
break;
}
}
return(block);
}
internal void ToUIText(TextBlock block, TypedConstant constant)
{
switch (constant.Kind)
{
case TypedConstantKind.Primitive:
if (constant.Value is bool)
{
block.Append((bool)constant.Value ? "true" : "false", Keyword);
}
else if (constant.Value is string)
{
block.Append(constant.ToCSharpString(), Text);
}
else
{
block.Append(constant.ToCSharpString(), Number);
}
break;
case TypedConstantKind.Enum:
var en = constant.ToCSharpString();
if (en.IndexOf('|') != -1)
{
var items = constant.Type.GetMembers().Where(i => {
var field = i as IFieldSymbol;
return(field != null &&
field.HasConstantValue != false &&
UnsafeArithmeticHelper.Equals(UnsafeArithmeticHelper.And(constant.Value, field.ConstantValue), field.ConstantValue) &&
UnsafeArithmeticHelper.IsZero(field.ConstantValue) == false);
});
var flags = items.ToArray();
for (int i = 0; i < flags.Length; i++)
{
if (i > 0)
{
block.Append(" | ");
}
block.Append(constant.Type.Name + "." + flags[i].Name, Enum);
}
}
else
{
block.Append(constant.Type.Name + en.Substring(en.LastIndexOf('.')), Enum);
}
break;
case TypedConstantKind.Type:
block.Append("typeof", Keyword).Append("(")
.AddSymbol((constant.Value as ITypeSymbol), null, this)
.Append(")");
break;
case TypedConstantKind.Array:
block.Append("{");
bool c = false;
foreach (var item in constant.Values)
{
if (c == false)
{
c = true;
}
else
{
block.Append(", ");
}
ToUIText(block, item);
}
block.Append("}");
break;
default:
block.Append(constant.ToCSharpString());
break;
}
}
static void ApplyClickAndGo(ISymbol symbol, ITextBuffer textBuffer, TextBlock description, IAsyncQuickInfoSession quickInfoSession)
{
if (symbol.Kind == SymbolKind.Namespace)
{
description.ToolTip = R.T_Locations + symbol.DeclaringSyntaxReferences.Length;
description.MouseEnter += HookEvents;
return;
}
if (symbol.Kind == SymbolKind.Method)
{
if (((IMethodSymbol)symbol).MethodKind == MethodKind.LambdaMethod)
{
using (var sbr = Microsoft.VisualStudio.Utilities.ReusableStringBuilder.AcquireDefault(30)) {
var sb = sbr.Resource;
sb.Append('(');
foreach (var item in ((IMethodSymbol)symbol).Parameters)
{
if (item.Ordinal > 0)
{
sb.Append(", ");
}
sb.Append(item.Type.ToDisplayString(CodeAnalysisHelper.QuickInfoSymbolDisplayFormat))
.Append(item.Type.GetParameterString())
.Append(' ')
.Append(item.Name);
}
sb.Append(')');
description.Append(sb.ToString(), ThemeHelper.DocumentTextBrush);
}
}
}
description.UseDummyToolTip();
if (symbol.HasSource() == false && symbol.ContainingType?.HasSource() == true)
{
// if the symbol is implicitly declared but its containing type is in source,
// navigate to the containing type
symbol = symbol.ContainingType;
}
description.MouseEnter += HookEvents;
void HookEvents(object sender, MouseEventArgs e)
{
var s = sender as FrameworkElement;
s.MouseEnter -= HookEvents;
HighlightSymbol(sender, e);
s.Cursor = Cursors.Hand;
if (symbol.Kind != SymbolKind.Namespace)
{
s.ToolTipOpening += ShowToolTip;
s.UseDummyToolTip();
}
s.MouseEnter += HighlightSymbol;
s.MouseLeave += RemoveSymbolHighlight;
s.MouseLeftButtonUp += GoToSource;
s.ContextMenuOpening += ShowContextMenu;
s.ContextMenuClosing += ReleaseQuickInfo;
}
async void GoToSource(object sender, MouseButtonEventArgs e)
{
await quickInfoSession.DismissAsync();
symbol.GoToDefinition();
}
void ShowToolTip(object sender, ToolTipEventArgs e)
{
var t = sender as TextBlock;
t.ToolTip = ShowSymbolLocation(symbol, symbol.HasSource() ? System.IO.Path.GetFileName(symbol.Locations[0].SourceTree.FilePath) : symbol.GetAssemblyModuleName());
t.ToolTipOpening -= ShowToolTip;
}
void HighlightSymbol(object sender, EventArgs e)
{
((TextBlock)sender).Background = (symbol.HasSource() ? SystemColors.HighlightBrush : SystemColors.GrayTextBrush).Alpha(0.3);
}
void RemoveSymbolHighlight(object sender, MouseEventArgs e)
{
((TextBlock)sender).Background = Brushes.Transparent;
}
void ShowContextMenu(object sender, ContextMenuEventArgs e)
{
var s = sender as FrameworkElement;
if (s.ContextMenu == null)
{
var ctx = SemanticContext.GetOrCreateSingetonInstance(quickInfoSession.TextView as IWpfTextView);
SyncHelper.RunSync(() => ctx.UpdateAsync(textBuffer, default));
var m = new CSharpSymbolContextMenu(ctx)
{
Symbol = symbol,
SyntaxNode = symbol.GetSyntaxNode()
};
m.AddAnalysisCommands();
if (m.HasItems)
{
m.Items.Add(new Separator());
}
m.AddSymbolNodeCommands();
m.AddTitleItem(symbol.GetOriginalName());
m.ItemClicked += HideQuickInfo;
s.ContextMenu = m;
}
HoldQuickInfo(s, true);
s.ContextMenu.IsOpen = true;
}
void ReleaseQuickInfo(object sender, ContextMenuEventArgs e)
{
HoldQuickInfo(sender as DependencyObject, false);
}
void HideQuickInfo(object sender, RoutedEventArgs e)
{
DismissQuickInfo(description);
}
}
static void ApplyClickAndGo(ISymbol symbol, ITextBuffer textBuffer, TextBlock description, IAsyncQuickInfoSession quickInfoSession)
{
if (symbol.Kind == SymbolKind.Namespace)
{
description.MouseEnter += HookEvents;
return;
}
if (symbol.Kind == SymbolKind.Method)
{
if (((IMethodSymbol)symbol).MethodKind == MethodKind.LambdaMethod)
{
using (var sbr = Microsoft.VisualStudio.Utilities.ReusableStringBuilder.AcquireDefault(30)) {
var sb = sbr.Resource;
sb.Append('(');
foreach (var item in ((IMethodSymbol)symbol).Parameters)
{
if (item.Ordinal > 0)
{
sb.Append(", ");
}
sb.Append(item.Type.ToDisplayString(CodeAnalysisHelper.QuickInfoSymbolDisplayFormat))
.Append(item.Type.GetParameterString())
.Append(' ')
.Append(item.Name);
}
sb.Append(')');
description.Append(sb.ToString(), ThemeHelper.DocumentTextBrush);
}
}
}
description.UseDummyToolTip();
if (symbol.HasSource() == false && symbol.ContainingType?.HasSource() == true)
{
// if the symbol is implicitly declared but its containing type is in source,
// navigate to the containing type
symbol = symbol.ContainingType;
}
description.MouseEnter += HookEvents;
void HookEvents(object sender, MouseEventArgs e)
{
var s = sender as FrameworkElement;
s.MouseEnter -= HookEvents;
HighlightSymbol(sender, e);
s.Cursor = Cursors.Hand;
s.ToolTipOpening += ShowToolTip;
s.UseDummyToolTip();
s.MouseEnter += HighlightSymbol;
s.MouseLeave += RemoveSymbolHighlight;
s.MouseLeftButtonUp += GoToSource;
s.ContextMenuOpening += ShowContextMenu;
s.ContextMenuClosing += ReleaseQuickInfo;
}
async void GoToSource(object sender, MouseButtonEventArgs e)
{
await quickInfoSession.DismissAsync();
symbol.GoToDefinition();
}
void ShowToolTip(object sender, ToolTipEventArgs e)
{
var t = sender as TextBlock;
t.ToolTip = ShowSymbolLocation(symbol, symbol.HasSource() ? System.IO.Path.GetFileName(symbol.Locations[0].SourceTree.FilePath) : symbol.GetAssemblyModuleName());
t.ToolTipOpening -= ShowToolTip;
}
void HighlightSymbol(object sender, EventArgs e)
{
((TextBlock)sender).Background = (symbol.HasSource() ? SystemColors.HighlightBrush : SystemColors.GrayTextBrush).Alpha(0.3);
}
void RemoveSymbolHighlight(object sender, MouseEventArgs e)
{
((TextBlock)sender).Background = Brushes.Transparent;
}
async void ShowContextMenu(object sender, ContextMenuEventArgs e)
{
await TH.JoinableTaskFactory.SwitchToMainThreadAsync(default);
public static TextBlock Append(this TextBlock block, string text, bool bold)
{
return(block.Append(text, bold, false, null));
}
public static TextBlock Append(this TextBlock block, string text, WpfBrush brush)
{
return(block.Append(text, false, false, brush));
}
