/// <summary>
/// Try to reteive relevant <see cref="ClassificationTypeNames"/> for the <paramref name="part"/>
/// </summary>
/// <returns>
/// <see langword="true"/> if the <see cref="SymbolDisplayPart.Kind"/> of <paramref name="part"/>
/// is not one of keyword or punctuation types
/// </returns>
public static bool TryGetClassificationName(SymbolDisplayPart part, out string classification)
{
classification =
part.Kind == SymbolDisplayPartKind.AliasName ? ClassificationTypeNames.Identifier :
part.Kind == SymbolDisplayPartKind.AnonymousTypeIndicator ? ClassificationTypeNames.Text :
part.Kind == SymbolDisplayPartKind.AssemblyName ? ClassificationTypeNames.Identifier :
part.Kind == SymbolDisplayPartKind.ClassName ? ClassificationTypeNames.ClassName :
part.Kind == SymbolDisplayPartKind.DelegateName ? ClassificationTypeNames.DelegateName :
part.Kind == SymbolDisplayPartKind.EnumName ? ClassificationTypeNames.EnumName : // TODO: enum meber
part.Kind == SymbolDisplayPartKind.ErrorTypeName ? ClassificationTypeNames.Identifier :
part.Kind == SymbolDisplayPartKind.EventName ? ClassificationTypeNames.EventName :
part.Kind == SymbolDisplayPartKind.FieldName ? ClassificationTypeNames.FieldName :
part.Kind == SymbolDisplayPartKind.InterfaceName ? ClassificationTypeNames.InterfaceName :
part.Kind == SymbolDisplayPartKind.LabelName ? ClassificationTypeNames.Identifier : // TODO: label name
part.Kind == SymbolDisplayPartKind.LocalName ? ClassificationTypeNames.LocalName :
part.Kind == SymbolDisplayPartKind.MethodName ? ClassificationTypeNames.MethodName :
part.Kind == SymbolDisplayPartKind.ModuleName ? ClassificationTypeNames.ModuleName :
part.Kind == SymbolDisplayPartKind.NamespaceName ? ClassificationTypeNames.Identifier : // TODO: namespace name
part.Kind == SymbolDisplayPartKind.ParameterName ? ClassificationTypeNames.ParameterName :
part.Kind == SymbolDisplayPartKind.PropertyName ? ClassificationTypeNames.PropertyName :
part.Kind == SymbolDisplayPartKind.RangeVariableName ? ClassificationTypeNames.Identifier : // TODO: range variable name
part.Kind == SymbolDisplayPartKind.StructName ? ClassificationTypeNames.StructName :
part.Kind == SymbolDisplayPartKind.TypeParameterName ? ClassificationTypeNames.TypeParameterName :
null;
return(!(classification is null));
}
public TaggedText ToTag(SymbolDisplayPart displayPart)
{
TaggedText ToTag()
{
if (displayPart.Symbol is null)
{
return(default);
protected override void WriteParameterName(ISymbol symbol, SymbolDisplayPart part)
{
if (DocumentationDisplayMode == DocumentationDisplayMode.ToolTip)
{
XElement element = DocumentationProvider?
.GetXmlDocumentation(symbol)?
.Element(WellKnownXmlTags.Param, "name", part.ToString());
if (element != null)
{
WriteStartElement("span");
WriteStartAttribute("title");
WriteDocumentationCommentToolTip(element);
WriteEndAttribute();
}
base.WriteParameterName(symbol, part);
if (element != null)
{
WriteEndElement();
}
}
else
{
base.WriteParameterName(symbol, part);
}
}
public static bool IsName(this SymbolDisplayPart displayPart) =>
displayPart.IsAnyKind(SymbolDisplayPartKind.ClassName, SymbolDisplayPartKind.DelegateName,
SymbolDisplayPartKind.EnumName, SymbolDisplayPartKind.EventName,
SymbolDisplayPartKind.FieldName, SymbolDisplayPartKind.InterfaceName,
SymbolDisplayPartKind.LocalName, SymbolDisplayPartKind.MethodName,
SymbolDisplayPartKind.NamespaceName, SymbolDisplayPartKind.ParameterName,
SymbolDisplayPartKind.PropertyName, SymbolDisplayPartKind.StructName);
internal static bool IsName(this SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.AliasName:
case SymbolDisplayPartKind.AssemblyName:
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.DelegateName:
case SymbolDisplayPartKind.EnumName:
case SymbolDisplayPartKind.ErrorTypeName:
case SymbolDisplayPartKind.EventName:
case SymbolDisplayPartKind.FieldName:
case SymbolDisplayPartKind.InterfaceName:
case SymbolDisplayPartKind.LabelName:
case SymbolDisplayPartKind.LocalName:
case SymbolDisplayPartKind.MethodName:
case SymbolDisplayPartKind.ModuleName:
case SymbolDisplayPartKind.NamespaceName:
case SymbolDisplayPartKind.ParameterName:
case SymbolDisplayPartKind.PropertyName:
case SymbolDisplayPartKind.StructName:
case SymbolDisplayPartKind.TypeParameterName:
case SymbolDisplayPartKind.RangeVariableName:
return(true);
default:
return(false);
}
}
private ImmutableArray <SymbolDisplayPart> AppendAccessorAttributes(
ImmutableArray <SymbolDisplayPart> parts,
IMethodSymbol method,
string keyword)
{
ImmutableArray <SymbolDisplayPart> attributeParts = SymbolDeclarationBuilder.GetAttributesParts(
method.GetAttributes(),
predicate: IsVisibleAttribute,
splitAttributes: Options.SplitAttributes,
includeAttributeArguments: Options.IncludeAttributeArguments,
addNewLine: false);
if (attributeParts.Any())
{
SymbolDisplayPart part = parts.FirstOrDefault(f => f.IsKeyword(keyword));
Debug.Assert(part.Kind == SymbolDisplayPartKind.Keyword);
if (part.Kind == SymbolDisplayPartKind.Keyword)
{
int index = parts.IndexOf(part);
parts = parts.Insert(index, SymbolDisplayPartFactory.Space());
parts = parts.InsertRange(index, attributeParts);
}
}
return(parts);
}
public static SymbolDisplayPart MassageErrorTypeNames(
this SymbolDisplayPart part,
string?replacement = null
)
{
if (part.Kind == SymbolDisplayPartKind.ErrorTypeName)
{
var text = part.ToString();
if (text == string.Empty)
{
return(replacement == null
? new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "object")
: new SymbolDisplayPart(SymbolDisplayPartKind.Text, null, replacement));
}
if (SyntaxFacts.GetKeywordKind(text) != SyntaxKind.None)
{
return(new SymbolDisplayPart(
SymbolDisplayPartKind.ErrorTypeName,
null,
string.Format("@{0}", text)
));
}
}
return(part);
}
private DisplayPartContent GetPartContent(SymbolDisplayPart item)
{
if (item.Kind == SymbolDisplayPartKind.NamespaceName || item.Kind == SymbolDisplayPartKind.Punctuation || item.Kind == SymbolDisplayPartKind.PropertyName)
{
return(new DisplayPartContent(item.ToString(), Brushes.Black));
}
else if (item.Kind == SymbolDisplayPartKind.ClassName || item.Kind == SymbolDisplayPartKind.InterfaceName || item.Kind == SymbolDisplayPartKind.EnumName || item.Kind == SymbolDisplayPartKind.DelegateName || item.Kind == SymbolDisplayPartKind.TypeParameterName)
{
return(new DisplayPartContent(item.ToString(), new SolidColorBrush(Color.FromRgb(43, 145, 175))));
}
else if (item.Kind == SymbolDisplayPartKind.MethodName || item.Kind == SymbolDisplayPartKind.ExtensionMethodName)
{
return(new DisplayPartContent(item.ToString(), new SolidColorBrush(Color.FromRgb(116, 83, 31))));
}
else if (item.Kind == SymbolDisplayPartKind.Keyword)
{
return(new DisplayPartContent(item.ToString(), Brushes.Blue));
}
else if (item.Kind == SymbolDisplayPartKind.ParameterName)
{
return(new DisplayPartContent(item.ToString(), Brushes.DarkSlateGray));
}
else if (item.Kind == SymbolDisplayPartKind.Space)
{
return(new DisplayPartContent(item.ToString(), Brushes.Transparent));
}
return(new DisplayPartContent());
}
private SymbolDisplayStyle GetDisplayCategory(SymbolDisplayPart symbolDisplayPart)
{
if (symbolDisplayPart.Kind == SymbolDisplayPartKind.MethodName)
{
return(SymbolDisplayStyle.MethodName);
}
return(SymbolDisplayStyle.Normal);
}
public override void Write(SymbolDisplayPart part)
{
base.Write(part);
if (part.Kind == SymbolDisplayPartKind.LineBreak)
{
_pendingIndentation = true;
}
}
public static bool IsAnyKind(this SymbolDisplayPart displayPart, params SymbolDisplayPartKind[] kinds)
{
foreach (var kind in kinds)
{
if (displayPart.Kind == kind)
{
return(true);
}
}
return(false);
}
public static void WriteSymbolDisplayPart(this IFastJsonWriter writer, SymbolDisplayPart part, bool selected)
{
writer.WriteStartObject();
writer.WriteProperty("text", part.ToString());
writer.WriteProperty("kind", FastConvert.EnumToLowerInvariantString(part.Kind));
if (selected)
{
writer.WriteProperty("selected", true);
}
writer.WriteEndObject();
}
private static JObject Categorize(SymbolDisplayPart part)
{
var kind = part.Kind.ToString();
kind = capital.Replace(kind, "$1-$2").ToLowerInvariant();
return(new JObject(
new JProperty("kind", new JValue(kind)),
new JProperty("val", new JValue(part.ToString()))
));
}
public static Run ToRun(this SymbolDisplayPart part)
{
var text = part.ToVisibleDisplayString(includeLeftToRightMarker: true);
var run = new Run(text);
//var format = formatMap.GetTextProperties(typeMap.GetClassificationType(part.Kind.ToClassificationTypeName()));
//run.SetTextProperties(format);
return(run);
}
private static void AddAccessorAttributes(
ImmutableArray <SymbolDisplayPart> .Builder parts,
IMethodSymbol methodSymbol,
SymbolDisplayFormat format,
SymbolDisplayAdditionalOptions additionalOptions,
Func <ISymbol, AttributeData, bool> shouldDisplayAttribute)
{
ImmutableArray <SymbolDisplayPart> attributeParts = GetAttributesParts(
methodSymbol,
format: format,
additionalOptions: additionalOptions,
shouldDisplayAttribute: shouldDisplayAttribute,
formatAttributes: false);
if (attributeParts.Any())
{
string keyword = GetKeyword();
SymbolDisplayPart part = parts.FirstOrDefault(f => f.IsKeyword(keyword));
Debug.Assert(part.Kind == SymbolDisplayPartKind.Keyword);
if (part.Kind == SymbolDisplayPartKind.Keyword)
{
int index = parts.IndexOf(part);
parts.Insert(index, SymbolDisplayPartFactory.Space());
parts.InsertRange(index, attributeParts);
}
}
string GetKeyword()
{
switch (methodSymbol.MethodKind)
{
case MethodKind.EventAdd:
return("add");
case MethodKind.EventRemove:
return("remove");
case MethodKind.PropertyGet:
return("get");
case MethodKind.PropertySet:
return("set");
default:
throw new InvalidOperationException();
}
}
}
protected override ImmutableArray <SymbolDisplayPart> .Builder GetAnonymousTypeParts(
SymbolDisplayPart part, ITypeSymbol anonymousType)
{
var builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>();
builder.Add(CreateSpaces(2));
builder.Add(part);
builder.Add(CreateSpaces(1));
builder.Add(CreateText("is"));
builder.Add(CreateSpaces(1));
builder.Add(CreateKeyword("New"));
builder.Add(CreateSpaces(1));
builder.Add(CreateKeyword("With"));
builder.Add(CreateSpaces(1));
builder.Add(CreatePunctuation("{"));
var wasAdded = false;
foreach (var member in anonymousType.GetMembers())
{
if (!(member is IPropertySymbol property) || !property.CanBeReferencedByName)
{
continue;
}
if (wasAdded)
{
builder.Add(CreatePunctuation(","));
}
wasAdded = true;
// NOTE: Key shows only for readonly properties
if (property.IsReadOnly)
{
builder.Add(CreateSpaces(1));
builder.Add(CreateKeyword("Key"));
}
builder.Add(CreateSpaces(1));
builder.Add(CreatePunctuation("."));
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.PropertyName, property, property.Name));
builder.Add(CreateSpaces(1));
builder.Add(CreateKeyword("As"));
builder.AddRange(ToMinimalDisplayParts(property.Type));
builder.Add(CreateSpaces(1));
}
builder.Add(CreateSpaces(1));
builder.Add(CreatePunctuation("}"));
return(builder);
}
SymbolDisplayPart Mutator(SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.Punctuation when part.ToString() == ".":
return(new SymbolDisplayPart(part.Kind, part.Symbol, "_"));
case SymbolDisplayPartKind.InterfaceName when part.ToString().StartsWith(Prefix.ProtectedToPublicInterface):
return(new SymbolDisplayPart(part.Kind, part.Symbol,
part.ToString().Replace(Prefix.ProtectedToPublicInterface, "")));
}
return(part);
}
public TokenApiView(SymbolDisplayPart part)
{
this.DisplayString = part.ToString();
this.IsNavigable = false;
if (part.Symbol == null)
{
this.Id = "";
}
else
{
var typeParamIndex = part.Symbol.ToDisplayString().LastIndexOf("<");
if (typeParamIndex > 0)
{
this.Id = part.Symbol.ToDisplayString().Remove(typeParamIndex);
}
else
{
this.Id = part.Symbol.ToDisplayString();
}
}
switch (part.Kind)
{
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.ErrorTypeName:
case SymbolDisplayPartKind.InterfaceName:
case SymbolDisplayPartKind.StructName:
this.Type = TypeReferenceApiView.TokenType.ClassType;
this.IsNavigable = true;
break;
case SymbolDisplayPartKind.EnumName:
this.Type = TypeReferenceApiView.TokenType.EnumType;
this.IsNavigable = true;
break;
case SymbolDisplayPartKind.Punctuation:
case SymbolDisplayPartKind.Space:
this.Type = TypeReferenceApiView.TokenType.Punctuation;
break;
case SymbolDisplayPartKind.Keyword:
this.Type = TypeReferenceApiView.TokenType.BuiltInType;
break;
default:
this.Type = TypeReferenceApiView.TokenType.TypeArgument;
break;
}
}
internal static bool IsMemberName(this SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.EventName:
case SymbolDisplayPartKind.FieldName:
case SymbolDisplayPartKind.MethodName:
case SymbolDisplayPartKind.PropertyName:
return(true);
default:
return(false);
}
}
internal static bool IsTypeName(this SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.DelegateName:
case SymbolDisplayPartKind.EnumName:
case SymbolDisplayPartKind.InterfaceName:
case SymbolDisplayPartKind.StructName:
return(true);
default:
return(false);
}
}
public static string ToVisibleDisplayString(this SymbolDisplayPart part, bool includeLeftToRightMarker)
{
var text = part.ToString();
if (includeLeftToRightMarker)
{
var classificationTypeName = part.Kind.ToClassificationTypeName();
if (classificationTypeName == ClassificationTypeNames.Punctuation ||
classificationTypeName == ClassificationTypeNames.WhiteSpace)
{
text = LeftToRightMarkerPrefix + text;
}
}
return(text);
}
public static string ToVisibleDisplayString(this SymbolDisplayPart part, bool includeLeftToRightMarker)
{
var text = part.ToString();
if (includeLeftToRightMarker)
{
if (part.Kind == SymbolDisplayPartKind.Punctuation ||
part.Kind == SymbolDisplayPartKind.Space ||
part.Kind == SymbolDisplayPartKind.LineBreak)
{
text = LeftToRightMarkerPrefix + text;
}
}
return(text);
}
public static IList <SymbolDisplayPart> ToAwaitableParts(this ISymbol symbol, string awaitKeyword, string initializedVariableName, SemanticModel semanticModel, int position)
{
var spacePart = new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, " ");
var parts = new List <SymbolDisplayPart>();
parts.AddLineBreak();
parts.AddText(WorkspacesResources.Usage_colon);
parts.AddLineBreak();
parts.AddText(" ");
var returnType = symbol.InferAwaitableReturnType(semanticModel, position);
returnType = returnType != null && returnType.SpecialType != SpecialType.System_Void ? returnType : null;
if (returnType != null)
{
if (semanticModel.Language == "C#")
{
parts.AddRange(returnType.ToMinimalDisplayParts(semanticModel, position));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.LocalName, null, initializedVariableName));
}
else
{
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "Dim"));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.LocalName, null, initializedVariableName));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "as"));
parts.Add(spacePart);
parts.AddRange(returnType.ToMinimalDisplayParts(semanticModel, position));
}
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, "="));
parts.Add(spacePart);
}
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, awaitKeyword));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.MethodName, symbol, symbol.Name));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, "("));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, symbol.GetParameters().Any() ? "..." : ""));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, ")"));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, semanticModel.Language == "C#" ? ";" : ""));
return(parts);
}
public static IList <SymbolDisplayPart> ReplaceAnonymousTypes(
IList <SymbolDisplayPart> parts,
IDictionary <INamedTypeSymbol, string> anonymousTypeToName)
{
var result = parts;
for (var i = 0; i < result.Count; i++)
{
var part = result[i];
if (part.Symbol is INamedTypeSymbol type && anonymousTypeToName.TryGetValue(type, out var name) && part.ToString() != name)
{
result = result == parts ? new List <SymbolDisplayPart>(parts) : result;
result[i] = new SymbolDisplayPart(part.Kind, part.Symbol, name);
}
}
return(result);
}
public static IList<SymbolDisplayPart> ReplaceAnonymousTypes(
IList<SymbolDisplayPart> parts,
IDictionary<INamedTypeSymbol, string> anonymousTypeToName)
{
var result = parts;
for (int i = 0; i < result.Count; i++)
{
var part = result[i];
var type = part.Symbol as INamedTypeSymbol;
if (type != null && anonymousTypeToName.TryGetValue(type, out var name) && part.ToString() != name)
{
result = result == parts ? new List<SymbolDisplayPart>(parts) : result;
result[i] = new SymbolDisplayPart(part.Kind, part.Symbol, name);
}
}
return result;
}
internal static bool IsTypeNameOrMemberName(this SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.DelegateName:
case SymbolDisplayPartKind.EnumName:
case SymbolDisplayPartKind.EventName:
case SymbolDisplayPartKind.FieldName:
case SymbolDisplayPartKind.InterfaceName:
case SymbolDisplayPartKind.MethodName:
case SymbolDisplayPartKind.PropertyName:
case SymbolDisplayPartKind.StructName:
return(true);
default:
return(false);
}
}
public static ImmutableArray <SymbolDisplayPart> RemoveAttributeSuffix(ImmutableArray <SymbolDisplayPart> parts)
{
SymbolDisplayPart part = parts.FirstOrDefault(f => f.Kind == SymbolDisplayPartKind.ClassName);
Debug.Assert(part.Kind == SymbolDisplayPartKind.ClassName, part.Kind.ToString());
if (part.Kind == SymbolDisplayPartKind.ClassName)
{
const string attributeSuffix = "Attribute";
string text = part.ToString();
if (text.EndsWith(attributeSuffix, StringComparison.Ordinal))
{
parts = parts.Replace(part, part.WithText(text.Remove(text.Length - attributeSuffix.Length)));
}
}
return(parts);
}
internal static bool IsMemberName(this SymbolDisplayPart part)
{
switch (part.Kind)
{
case SymbolDisplayPartKind.EventName:
case SymbolDisplayPartKind.FieldName:
case SymbolDisplayPartKind.MethodName:
case SymbolDisplayPartKind.ExtensionMethodName:
case SymbolDisplayPartKind.PropertyName:
case SymbolDisplayPartKind.EnumMemberName:
case SymbolDisplayPartKind.ConstantName:
return(true);
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.StructName:
return(part.Symbol is IMethodSymbol methodSymbol && methodSymbol.MethodKind.Is(MethodKind.Constructor, MethodKind.Destructor));
default:
return(false);
}
}
private static Run ToRun(this SymbolDisplayPart text)
{
var run = new Run(text.ToString());
switch (text.Kind)
{
case SymbolDisplayPartKind.Keyword:
run.Foreground = Brushes.Blue;
break;
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.DelegateName:
case SymbolDisplayPartKind.EnumName:
case SymbolDisplayPartKind.EventName:
case SymbolDisplayPartKind.InterfaceName:
case SymbolDisplayPartKind.StructName:
run.Foreground = Brushes.Teal;
break;
}
return(run);
}
public static Run ToRun(this SymbolDisplayPart part)
{
var text = part.ToVisibleDisplayString(includeLeftToRightMarker: true);
var run = new Run(text);
switch (part.Kind)
{
case SymbolDisplayPartKind.Keyword:
run.Foreground = Brushes.Blue;
break;
case SymbolDisplayPartKind.StructName:
case SymbolDisplayPartKind.EnumName:
case SymbolDisplayPartKind.TypeParameterName:
case SymbolDisplayPartKind.ClassName:
case SymbolDisplayPartKind.DelegateName:
case SymbolDisplayPartKind.InterfaceName:
run.Foreground = Brushes.Teal;
break;
}
return(run);
}
/// <summary>
/// シンボル名を返す
/// </summary>
/// <param name="target">対象DisplayPartsインスタンス</param>
/// <param name="exclusionGenericElements">ジェネリックス要素の除外</param>
/// <returns>シンボル名</returns>
internal static string GetSymbolName(SymbolDisplayPart target, bool exclusionGenericElements = false)
{
if (target.Symbol is null)
{
return($"{target}");
}
var name = GetSymbolName(target.Symbol);
// ジェネリックスの場合はパラメータ除去
if (exclusionGenericElements && target.Symbol is INamedTypeSymbol symbol && symbol.IsGenericType)
{
if (name.EndsWith(">", StringComparison.CurrentCulture))
{
name = name.Substring(0, name.IndexOf("<", StringComparison.CurrentCulture));
}
else
{
name = $"{target}";
}
}
return(name);
}
private void Initialize()
{
var content = new StringBuilder();
var prettyPrintedContent = new StringBuilder();
var parts = new List<SymbolDisplayPart>();
var prettyPrintedParts = new List<SymbolDisplayPart>();
var parameters = new List<IParameter>();
var signaturePrefixParts = _signatureHelpItem.PrefixDisplayParts;
var signaturePrefixContent = _signatureHelpItem.PrefixDisplayParts.GetFullText();
AddRange(signaturePrefixParts, parts, prettyPrintedParts);
Append(signaturePrefixContent, content, prettyPrintedContent);
var separatorParts = _signatureHelpItem.SeparatorDisplayParts;
var separatorContent = separatorParts.GetFullText();
var newLinePart = new SymbolDisplayPart(SymbolDisplayPartKind.LineBreak, null, "\r\n");
var newLineContent = newLinePart.ToString();
var spacerPart = new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, new string(' ', signaturePrefixContent.Length));
var spacerContent = spacerPart.ToString();
var paramColumnCount = 0;
for (int i = 0; i < _signatureHelpItem.Parameters.Length; i++)
{
var sigHelpParameter = _signatureHelpItem.Parameters[i];
var parameterPrefixParts = sigHelpParameter.PrefixDisplayParts;
var parameterPrefixContext = sigHelpParameter.PrefixDisplayParts.GetFullText();
var parameterParts = AddOptionalBrackets(sigHelpParameter.IsOptional, sigHelpParameter.DisplayParts);
var parameterContent = parameterParts.GetFullText();
var parameterSuffixParts = sigHelpParameter.SuffixDisplayParts;
var parameterSuffixContext = sigHelpParameter.SuffixDisplayParts.GetFullText();
paramColumnCount += separatorContent.Length + parameterPrefixContext.Length + parameterContent.Length + parameterSuffixContext.Length;
if (i > 0)
{
AddRange(separatorParts, parts, prettyPrintedParts);
Append(separatorContent, content, prettyPrintedContent);
if (paramColumnCount > MaxParamColumnCount)
{
prettyPrintedParts.Add(newLinePart);
prettyPrintedParts.Add(spacerPart);
prettyPrintedContent.Append(newLineContent);
prettyPrintedContent.Append(spacerContent);
paramColumnCount = 0;
}
}
AddRange(parameterPrefixParts, parts, prettyPrintedParts);
Append(parameterPrefixContext, content, prettyPrintedContent);
parameters.Add(new Parameter(this, sigHelpParameter, parameterContent, content.Length, prettyPrintedContent.Length));
AddRange(parameterParts, parts, prettyPrintedParts);
Append(parameterContent, content, prettyPrintedContent);
AddRange(parameterSuffixParts, parts, prettyPrintedParts);
Append(parameterSuffixContext, content, prettyPrintedContent);
}
AddRange(_signatureHelpItem.SuffixDisplayParts, parts, prettyPrintedParts);
Append(_signatureHelpItem.SuffixDisplayParts.GetFullText(), content, prettyPrintedContent);
if (_parameterIndex >= 0)
{
var sigHelpParameter = _signatureHelpItem.Parameters[_parameterIndex];
AddRange(sigHelpParameter.SelectedDisplayParts, parts, prettyPrintedParts);
Append(sigHelpParameter.SelectedDisplayParts.GetFullText(), content, prettyPrintedContent);
}
AddRange(_signatureHelpItem.DescriptionParts, parts, prettyPrintedParts);
Append(_signatureHelpItem.DescriptionParts.GetFullText(), content, prettyPrintedContent);
var documentation = _signatureHelpItem.DocumentationFactory(CancellationToken.None).ToList();
if (documentation.Count > 0)
{
AddRange(new[] { newLinePart }, parts, prettyPrintedParts);
Append(newLineContent, content, prettyPrintedContent);
AddRange(documentation, parts, prettyPrintedParts);
Append(documentation.GetFullText(), content, prettyPrintedContent);
}
_content = content.ToString();
_prettyPrintedContent = prettyPrintedContent.ToString();
_displayParts = parts.ToImmutableArrayOrEmpty();
_prettyPrintedDisplayParts = prettyPrintedParts.ToImmutableArrayOrEmpty();
_parameters = parameters.ToReadOnlyCollection();
}
private static bool CompareParts(SymbolDisplayPart p1, SymbolDisplayPart p2)
{
return p1.ToString() == p2.ToString();
}
public static IList<SymbolDisplayPart> ToAwaitableParts(this ISymbol symbol, string awaitKeyword, string initializedVariableName, SemanticModel semanticModel, int position)
{
var spacePart = new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, " ");
var parts = new List<SymbolDisplayPart>();
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Text, null, $"\r\n{WorkspacesResources.Usage_colon}\r\n "));
var returnType = symbol.InferAwaitableReturnType(semanticModel, position);
returnType = returnType != null && returnType.SpecialType != SpecialType.System_Void ? returnType : null;
if (returnType != null)
{
if (semanticModel.Language == "C#")
{
parts.AddRange(returnType.ToMinimalDisplayParts(semanticModel, position));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.LocalName, null, initializedVariableName));
}
else
{
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "Dim"));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.LocalName, null, initializedVariableName));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, "as"));
parts.Add(spacePart);
parts.AddRange(returnType.ToMinimalDisplayParts(semanticModel, position));
}
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, "="));
parts.Add(spacePart);
}
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Keyword, null, awaitKeyword));
parts.Add(spacePart);
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.MethodName, symbol, symbol.Name));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, "("));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, symbol.GetParameters().Any() ? "..." : ""));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, ")"));
parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.Punctuation, null, semanticModel.Language == "C#" ? ";" : ""));
return parts;
}
