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)); }