private IEnumerable<SignatureHelpItem> GetDelegateInvokeItems(
InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService, ISymbol within, INamedTypeSymbol delegateType, CancellationToken cancellationToken)
{
var invokeMethod = delegateType.DelegateInvokeMethod;
if (invokeMethod == null)
{
return null;
}
// Events can only be invoked directly from the class they were declared in.
var expressionSymbol = semanticModel.GetSymbolInfo(invocationExpression.Expression, cancellationToken).GetAnySymbol();
if (expressionSymbol.IsKind(SymbolKind.Event) &&
!expressionSymbol.ContainingType.OriginalDefinition.Equals(within.OriginalDefinition))
{
return null;
}
var position = invocationExpression.SpanStart;
var item = CreateItem(
invokeMethod, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
isVariadic: invokeMethod.IsParams(),
documentation: SpecializedCollections.EmptyEnumerable<SymbolDisplayPart>(),
prefixParts: GetDelegateInvokePreambleParts(invokeMethod, semanticModel, position),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateInvokePostambleParts(),
parameters: GetDelegateInvokeParameters(invokeMethod, semanticModel, position, documentationCommentFormattingService, cancellationToken));
return SpecializedCollections.SingletonEnumerable(item);
}
protected override async Task<Document> ConvertDocCommentsToRegularComments(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken)
{
var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newSyntaxRoot = DocCommentConverter.ConvertToRegularComments(syntaxRoot, docCommentFormattingService, cancellationToken);
return document.WithSyntaxRoot(newSyntaxRoot);
}
private IEnumerable<SignatureHelpItem> GetMethodGroupItems(
InvocationExpressionSyntax invocationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
ISymbol within,
IEnumerable<IMethodSymbol> methodGroup,
CancellationToken cancellationToken)
{
ITypeSymbol throughType = null;
if (invocationExpression.Expression is MemberAccessExpressionSyntax)
{
var throughExpression = ((MemberAccessExpressionSyntax)invocationExpression.Expression).Expression;
var throughSymbol = semanticModel.GetSymbolInfo(throughExpression, cancellationToken).GetAnySymbol();
// if it is via a base expression "base.", we know the "throughType" is the base class but
// we need to be able to tell between "base.M()" and "new Base().M()".
// currently, Access check methods do not differentiate between them.
// so handle "base." primary-expression here by nulling out "throughType"
if (!(throughExpression is BaseExpressionSyntax))
{
throughType = semanticModel.GetTypeInfo(throughExpression, cancellationToken).Type;
}
var includeInstance = !throughExpression.IsKind(SyntaxKind.IdentifierName) ||
semanticModel.LookupSymbols(throughExpression.SpanStart, name: throughSymbol.Name).Any(s => !(s is INamedTypeSymbol)) ||
(!(throughSymbol is INamespaceOrTypeSymbol) && semanticModel.LookupSymbols(throughExpression.SpanStart, container: throughSymbol.ContainingType).Any(s => !(s is INamedTypeSymbol)));
var includeStatic = throughSymbol is INamedTypeSymbol ||
(throughExpression.IsKind(SyntaxKind.IdentifierName) &&
semanticModel.LookupNamespacesAndTypes(throughExpression.SpanStart, name: throughSymbol.Name).Any(t => t.GetSymbolType() == throughType));
Contract.ThrowIfFalse(includeInstance || includeStatic);
methodGroup = methodGroup.Where(m => (m.IsStatic && includeStatic) || (!m.IsStatic && includeInstance));
}
else if (invocationExpression.Expression is SimpleNameSyntax &&
invocationExpression.IsInStaticContext())
{
methodGroup = methodGroup.Where(m => m.IsStatic);
}
var accessibleMethods = methodGroup.Where(m => m.IsAccessibleWithin(within, throughTypeOpt: throughType)).ToList();
if (accessibleMethods.Count == 0)
{
return null;
}
var methodSet = accessibleMethods.ToSet();
accessibleMethods = accessibleMethods.Where(m => !IsHiddenByOtherMethod(m, methodSet)).ToList();
return accessibleMethods.Select(m =>
ConvertMethodGroupMethod(m, invocationExpression, semanticModel, symbolDisplayService, anonymousTypeDisplayService, documentationCommentFormattingService, cancellationToken));
}
private IEnumerable<SignatureHelpParameter> GetDelegateInvokeParameters(
IMethodSymbol invokeMethod, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
{
foreach (var parameter in invokeMethod.Parameters)
{
yield return new SignatureHelpParameter(
parameter.Name,
parameter.IsOptional,
parameter.GetDocumentationParts(semanticModel, position, formattingService, cancellationToken),
parameter.ToMinimalDisplayParts(semanticModel, position));
}
}
protected static SignatureHelpParameter Convert(
IParameterSymbol parameter,
SemanticModel semanticModel,
int position,
IDocumentationCommentFormattingService formatter,
CancellationToken cancellationToken)
{
return new SignatureHelpParameter(
parameter.Name,
parameter.IsOptional,
parameter.GetDocumentationPartsFactory(semanticModel, position, formatter),
parameter.ToMinimalDisplayParts(semanticModel, position));
}
private IList<SignatureHelpSymbolParameter> GetDelegateInvokeParameters(
IMethodSymbol invokeMethod, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
{
var result = new List<SignatureHelpSymbolParameter>();
foreach (var parameter in invokeMethod.Parameters)
{
cancellationToken.ThrowIfCancellationRequested();
result.Add(new SignatureHelpSymbolParameter(
parameter.Name,
parameter.IsOptional,
parameter.GetDocumentationPartsFactory(semanticModel, position, formattingService),
parameter.ToMinimalDisplayParts(semanticModel, position)));
}
return result;
}
private IList<SignatureHelpItem> GetNormalTypeConstructors(
Document document,
ObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
INamedTypeSymbol normalType,
ISymbol within,
CancellationToken cancellationToken)
{
var accessibleConstructors = normalType.InstanceConstructors
.Where(c => c.IsAccessibleWithin(within))
.Where(s => s.IsEditorBrowsable(document.ShouldHideAdvancedMembers(), semanticModel.Compilation))
.Sort(symbolDisplayService, semanticModel, objectCreationExpression.SpanStart);
return accessibleConstructors.Select(c =>
ConvertNormalTypeConstructor(c, objectCreationExpression, semanticModel, symbolDisplayService, anonymousTypeDisplayService, documentationCommentFormattingService, cancellationToken)).ToList();
}
public WrappedNamedTypeSymbol(INamedTypeSymbol symbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(symbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = symbol;
var allMembers = _symbol.GetMembers();
var filteredMembers = from m in allMembers
where !m.HasUnsupportedMetadata
where m.DeclaredAccessibility == Accessibility.Public ||
m.DeclaredAccessibility == Accessibility.Protected ||
m.DeclaredAccessibility == Accessibility.ProtectedOrInternal
where m.Kind == SymbolKind.Event ||
m.Kind == SymbolKind.Field ||
m.Kind == SymbolKind.Method ||
m.Kind == SymbolKind.NamedType ||
m.Kind == SymbolKind.Property
select WrapMember(m, canImplementImplicitly, docCommentFormattingService);
_members = ImmutableArray.CreateRange<ISymbol>(filteredMembers);
}
private SignatureHelpItem ConvertNormalTypeConstructor(
IMethodSymbol constructor,
ObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = objectCreationExpression.SpanStart;
var item = CreateItem(
constructor, semanticModel, position,
anonymousTypeDisplayService,
constructor.IsParams(),
constructor.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetNormalTypePreambleParts(constructor, semanticModel, position),
GetSeparatorParts(),
GetNormalTypePostambleParts(constructor),
constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
return(item);
}
private SignatureHelpItem Convert(
IPropertySymbol indexer,
SyntaxToken openToken,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = openToken.SpanStart;
var item = CreateItem(indexer, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
indexer.IsParams(),
indexer.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetPreambleParts(indexer, position, semanticModel),
GetSeparatorParts(),
GetPostambleParts(indexer),
indexer.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
return(item);
}
private SignatureHelpItem Convert(
ISymbol symbol,
SyntaxToken lessThanToken,
SemanticModel semanticModel,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = lessThanToken.SpanStart;
SignatureHelpItem item;
if (symbol is INamedTypeSymbol namedType)
{
item = CreateItem(
symbol, semanticModel, position,
anonymousTypeDisplayService,
false,
symbol.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetPreambleParts(namedType, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(namedType),
namedType.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
}
else
{
var method = (IMethodSymbol)symbol;
item = CreateItem(
symbol, semanticModel, position,
anonymousTypeDisplayService,
false,
c => symbol.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, c),
GetPreambleParts(method, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(method, semanticModel, position),
method.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
}
return(item);
}
private SignatureHelpItem Convert(
IMethodSymbol constructor,
SyntaxToken openToken,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = openToken.SpanStart;
var item = CreateItem(
constructor, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
constructor.IsParams(),
constructor.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, cancellationToken),
GetPreambleParts(constructor, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(constructor),
constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)));
return(item);
}
private static IList <SignatureHelpItem> GetDelegateOrFunctionPointerInvokeItems(
InvocationExpressionSyntax invocationExpression,
IMethodSymbol invokeMethod,
SemanticModel semanticModel,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
out int?selectedItem,
CancellationToken cancellationToken
)
{
var position = invocationExpression.SpanStart;
var item = CreateItem(
invokeMethod,
semanticModel,
position,
anonymousTypeDisplayService,
isVariadic: invokeMethod.IsParams(),
documentationFactory: null,
prefixParts: GetDelegateOrFunctionPointerInvokePreambleParts(
invokeMethod,
semanticModel,
position
),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateOrFunctionPointerInvokePostambleParts(),
parameters: GetDelegateOrFunctionPointerInvokeParameters(
invokeMethod,
semanticModel,
position,
documentationCommentFormattingService,
cancellationToken
)
);
// Since we're returning a single item, we can selected it as the "best one".
selectedItem = 0;
return(SpecializedCollections.SingletonList(item));
}
private IEnumerable <SignatureHelpParameter> GetParameters(
IMethodSymbol constructor,
SemanticModel semanticModel,
int position,
IList <ISymbol> namedParameters,
IDocumentationCommentFormattingService documentationCommentFormatter,
CancellationToken cancellationToken)
{
foreach (var parameter in constructor.Parameters)
{
yield return(Convert(parameter, semanticModel, position, documentationCommentFormatter, cancellationToken));
}
for (int i = 0; i < namedParameters.Count; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var namedParameter = namedParameters[i];
var type = namedParameter is IFieldSymbol ? ((IFieldSymbol)namedParameter).Type : ((IPropertySymbol)namedParameter).Type;
var displayParts = new List <SymbolDisplayPart>();
displayParts.Add(new SymbolDisplayPart(
namedParameter is IFieldSymbol ? SymbolDisplayPartKind.FieldName : SymbolDisplayPartKind.PropertyName,
namedParameter, namedParameter.Name.ToIdentifierToken().ToString()));
displayParts.Add(Space());
displayParts.Add(Punctuation(SyntaxKind.EqualsToken));
displayParts.Add(Space());
displayParts.AddRange(type.ToMinimalDisplayParts(semanticModel, position));
yield return(new SignatureHelpParameter(
namedParameter.Name,
isOptional: true,
documentationFactory: namedParameter.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormatter),
displayParts: displayParts,
prefixDisplayParts: GetParameterPrefixDisplayParts(i)));
}
}
private static void AddDocumentationPart(
List <TaggedText> textContentBuilder,
ISymbol symbol,
SemanticModel semanticModel,
int position,
IDocumentationCommentFormattingService formatter,
CancellationToken cancellationToken
)
{
var documentation = symbol.GetDocumentationParts(
semanticModel,
position,
formatter,
cancellationToken
);
if (documentation.Any())
{
textContentBuilder.AddLineBreak();
textContentBuilder.AddRange(documentation);
}
}
private static ISymbol WrapMember(ISymbol m, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
{
switch (m.Kind)
{
case SymbolKind.Field:
return new WrappedFieldSymbol((IFieldSymbol)m, docCommentFormattingService);
case SymbolKind.Event:
return new WrappedEventSymbol((IEventSymbol)m, canImplementImplicitly, docCommentFormattingService);
case SymbolKind.Method:
return new WrappedMethodSymbol((IMethodSymbol)m, canImplementImplicitly, docCommentFormattingService);
case SymbolKind.NamedType:
return new WrappedNamedTypeSymbol((INamedTypeSymbol)m, canImplementImplicitly, docCommentFormattingService);
case SymbolKind.Property:
return new WrappedPropertySymbol((IPropertySymbol)m, canImplementImplicitly, docCommentFormattingService);
}
throw ExceptionUtilities.Unreachable;
}
private SignatureHelpItem ConvertMethodGroupMethod(
IMethodSymbol method,
InvocationExpressionSyntax invocationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = invocationExpression.SpanStart;
var item = CreateItem(
method, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
method.IsParams(),
c => method.OriginalDefinition.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, c).Concat(GetAwaitableUsage(method, semanticModel, position)),
GetMethodGroupPreambleParts(method, semanticModel, position),
GetSeparatorParts(),
GetMethodGroupPostambleParts(method),
method.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)));
return(item);
}
private SignatureHelpItem ConvertNormalTypeConstructor(
IMethodSymbol constructor,
ObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = objectCreationExpression.SpanStart;
var item = CreateItem(
constructor, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
constructor.IsParams(),
constructor.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, cancellationToken),
GetNormalTypePreambleParts(constructor, semanticModel, position),
GetSeparatorParts(),
GetNormalTypePostambleParts(constructor),
constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)));
return item;
}
private static SignatureHelpSymbolParameter Convert(
ITypeParameterSymbol parameter,
SemanticModel semanticModel,
int position,
IDocumentationCommentFormattingService formatter
)
{
return(new SignatureHelpSymbolParameter(
parameter.Name,
isOptional: false,
documentationFactory: parameter.GetDocumentationPartsFactory(
semanticModel,
position,
formatter
),
displayParts: parameter.ToMinimalDisplayParts(
semanticModel,
position,
s_minimallyQualifiedFormat
),
selectedDisplayParts: GetSelectedDisplayParts(parameter, semanticModel, position)
));
}
private static IList <SignatureHelpItem>?GetDelegateInvokeItems(
InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, IStructuralTypeDisplayService structuralTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService, ISymbol within, INamedTypeSymbol delegateType, out int?selectedItem, CancellationToken cancellationToken)
{
selectedItem = null;
var invokeMethod = delegateType.DelegateInvokeMethod;
if (invokeMethod == null)
{
return(null);
}
// Events can only be invoked directly from the class they were declared in.
var expressionSymbol = semanticModel.GetSymbolInfo(invocationExpression.Expression, cancellationToken).GetAnySymbol();
if (expressionSymbol.IsKind(SymbolKind.Event) &&
!expressionSymbol.ContainingType.OriginalDefinition.Equals(within.OriginalDefinition))
{
return(null);
}
return(GetDelegateOrFunctionPointerInvokeItems(invocationExpression, invokeMethod, semanticModel, structuralTypeDisplayService, documentationCommentFormattingService, out selectedItem, cancellationToken));
}
private static (IList <SignatureHelpItem> items, int?selectedItem) GetNormalTypeConstructors(
BaseObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
IStructuralTypeDisplayService structuralTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
INamedTypeSymbol normalType,
ISymbol within,
SignatureHelpOptions options,
CancellationToken cancellationToken)
{
var accessibleConstructors = normalType.InstanceConstructors
.WhereAsArray(c => c.IsAccessibleWithin(within))
.WhereAsArray(s => s.IsEditorBrowsable(options.HideAdvancedMembers, semanticModel.Compilation))
.Sort(semanticModel, objectCreationExpression.SpanStart);
var symbolInfo = semanticModel.GetSymbolInfo(objectCreationExpression, cancellationToken);
var selectedItem = TryGetSelectedIndex(accessibleConstructors, symbolInfo.Symbol);
var items = accessibleConstructors.SelectAsArray(c =>
ConvertNormalTypeConstructor(c, objectCreationExpression, semanticModel, structuralTypeDisplayService, documentationCommentFormattingService));
return(items, selectedItem);
}
private IList <SignatureHelpItem> GetDelegateInvokeItems(
InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService, ISymbol within, INamedTypeSymbol delegateType, out int?selectedItem, CancellationToken cancellationToken)
{
selectedItem = null;
var invokeMethod = delegateType.DelegateInvokeMethod;
if (invokeMethod == null)
{
return(null);
}
// Events can only be invoked directly from the class they were declared in.
var expressionSymbol = semanticModel.GetSymbolInfo(invocationExpression.Expression, cancellationToken).GetAnySymbol();
if (expressionSymbol.IsKind(SymbolKind.Event) &&
!expressionSymbol.ContainingType.OriginalDefinition.Equals(within.OriginalDefinition))
{
return(null);
}
var position = invocationExpression.SpanStart;
var item = CreateItem(
invokeMethod, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
isVariadic: invokeMethod.IsParams(),
documentationFactory: null,
prefixParts: GetDelegateInvokePreambleParts(invokeMethod, semanticModel, position),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateInvokePostambleParts(),
parameters: GetDelegateInvokeParameters(invokeMethod, semanticModel, position, documentationCommentFormattingService, cancellationToken));
// Since we're returning a single item, we can selected it as the "best one".
selectedItem = 0;
return(SpecializedCollections.SingletonList(item));
}
private IDeferredQuickInfoContent GetDocumentationContent(
IEnumerable <ISymbol> symbols,
IDictionary <SymbolDescriptionGroups, ImmutableArray <TaggedText> > sections,
SemanticModel semanticModel,
SyntaxToken token,
IDocumentationCommentFormattingService formatter,
ISyntaxFactsService syntaxFactsService,
CancellationToken cancellationToken)
{
if (sections.ContainsKey(SymbolDescriptionGroups.Documentation))
{
var documentationBuilder = new List <TaggedText>();
documentationBuilder.AddRange(sections[SymbolDescriptionGroups.Documentation]);
return(_contentProvider.CreateClassifiableDeferredContent(documentationBuilder));
}
if (symbols.Any())
{
var symbol = symbols.First().OriginalDefinition;
// if generating quick info for an attribute, bind to the class instead of the constructor
if (syntaxFactsService.IsAttributeName(token.Parent) &&
symbol.ContainingType?.IsAttribute() == true)
{
symbol = symbol.ContainingType;
}
var documentation = symbol.GetDocumentationParts(semanticModel, token.SpanStart, formatter, cancellationToken);
if (documentation != null)
{
return(_contentProvider.CreateClassifiableDeferredContent(documentation.ToList()));
}
}
return(_contentProvider.CreateDocumentationCommentDeferredContent(null));
}
private IEnumerable <SignatureHelpItem> GetNormalTypeConstructors(
Document document,
ObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
INamedTypeSymbol normalType,
ISymbol within,
CancellationToken cancellationToken)
{
var accessibleConstructors = normalType.InstanceConstructors
.Where(c => c.IsAccessibleWithin(within))
.Where(s => s.IsEditorBrowsable(document.ShouldHideAdvancedMembers(), semanticModel.Compilation))
.Sort(symbolDisplayService, semanticModel, objectCreationExpression.SpanStart);
if (!accessibleConstructors.Any())
{
return(null);
}
return(accessibleConstructors.Select(c =>
ConvertNormalTypeConstructor(c, objectCreationExpression, semanticModel, symbolDisplayService, anonymousTypeDisplayService, documentationCommentFormattingService, cancellationToken)));
}
internal static ImmutableArray <string> Format(IDocumentationCommentFormattingService docCommentFormattingService, DocumentationComment docComment)
{
var formattedCommentLinesBuilder = ArrayBuilder <string> .GetInstance();
var lineBuilder = new StringBuilder();
var formattedSummaryText = docCommentFormattingService.Format(docComment.SummaryText);
if (!string.IsNullOrWhiteSpace(formattedSummaryText))
{
formattedCommentLinesBuilder.Add(s_summaryHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedSummaryText));
}
var parameterNames = docComment.ParameterNames;
if (parameterNames.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_paramHeader);
for (var i = 0; i < parameterNames.Length; i++)
{
if (i != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, parameterNames[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var rawParameterText = docComment.GetParameterText(parameterNames[i]);
var formattedParameterText = docCommentFormattingService.Format(rawParameterText);
if (!string.IsNullOrWhiteSpace(formattedParameterText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedParameterText));
}
}
}
var typeParameterNames = docComment.TypeParameterNames;
if (typeParameterNames.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_typeParameterHeader);
for (var i = 0; i < typeParameterNames.Length; i++)
{
if (i != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, typeParameterNames[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var rawTypeParameterText = docComment.GetTypeParameterText(typeParameterNames[i]);
var formattedTypeParameterText = docCommentFormattingService.Format(rawTypeParameterText);
if (!string.IsNullOrWhiteSpace(formattedTypeParameterText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedTypeParameterText));
}
}
}
var formattedReturnsText = docCommentFormattingService.Format(docComment.ReturnsText);
if (!string.IsNullOrWhiteSpace(formattedReturnsText))
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_returnsHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedReturnsText));
}
var formattedValueText = docCommentFormattingService.Format(docComment.ValueText);
if (!string.IsNullOrWhiteSpace(formattedValueText))
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_valueHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedValueText));
}
var exceptionTypes = docComment.ExceptionTypes;
if (exceptionTypes.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_exceptionsHeader);
for (var i = 0; i < exceptionTypes.Length; i++)
{
var rawExceptionTexts = docComment.GetExceptionTexts(exceptionTypes[i]);
for (var j = 0; j < rawExceptionTexts.Length; j++)
{
if (i != 0 || j != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, exceptionTypes[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var formattedExceptionText = docCommentFormattingService.Format(rawExceptionTexts[j]);
if (!string.IsNullOrWhiteSpace(formattedExceptionText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedExceptionText));
}
}
}
}
var formattedRemarksText = docCommentFormattingService.Format(docComment.RemarksText);
if (!string.IsNullOrWhiteSpace(formattedRemarksText))
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_remarksHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedRemarksText));
}
// Eliminate any blank lines at the beginning.
while (formattedCommentLinesBuilder.Count > 0 &&
formattedCommentLinesBuilder[0].Length == 0)
{
formattedCommentLinesBuilder.RemoveAt(0);
}
// Eliminate any blank lines at the end.
while (formattedCommentLinesBuilder.Count > 0 &&
formattedCommentLinesBuilder[^ 1].Length == 0)
{
formattedCommentLinesBuilder.RemoveAt(formattedCommentLinesBuilder.Count - 1);
}
return(formattedCommentLinesBuilder.ToImmutableAndFree());
}
public WrappedEventSymbol(IEventSymbol eventSymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(eventSymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = eventSymbol;
}
protected AbstractWrappedSymbol(ISymbol symbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
{
_symbol = symbol;
CanImplementImplicitly = canImplementImplicitly;
DocCommentFormattingService = docCommentFormattingService;
}
private static IList <SignatureHelpItem> GetFunctionPointerInvokeItems(
InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, IStructuralTypeDisplayService structuralTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService, IFunctionPointerTypeSymbol functionPointerType, out int?selectedItem, CancellationToken cancellationToken)
{
return(GetDelegateOrFunctionPointerInvokeItems(invocationExpression, functionPointerType.Signature, semanticModel, structuralTypeDisplayService, documentationCommentFormattingService, out selectedItem, cancellationToken));
}
internal static ImmutableArray<string> Format(IDocumentationCommentFormattingService docCommentFormattingService, DocumentationComment docComment)
{
var formattedCommentLinesBuilder = ImmutableArray.CreateBuilder<string>();
var lineBuilder = new StringBuilder();
var formattedSummaryText = docCommentFormattingService.Format(docComment.SummaryText);
if (!string.IsNullOrWhiteSpace(formattedSummaryText))
{
formattedCommentLinesBuilder.Add(s_summaryHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedSummaryText));
}
var parameterNames = docComment.ParameterNames;
if (parameterNames.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_paramHeader);
for (int i = 0; i < parameterNames.Length; i++)
{
if (i != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, parameterNames[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var rawParameterText = docComment.GetParameterText(parameterNames[i]);
var formattedParameterText = docCommentFormattingService.Format(rawParameterText);
if (!string.IsNullOrWhiteSpace(formattedParameterText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedParameterText));
}
}
}
var typeParameterNames = docComment.TypeParameterNames;
if (typeParameterNames.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_typeParameterHeader);
for (int i = 0; i < typeParameterNames.Length; i++)
{
if (i != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, typeParameterNames[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var rawTypeParameterText = docComment.GetTypeParameterText(typeParameterNames[i]);
var formattedTypeParameterText = docCommentFormattingService.Format(rawTypeParameterText);
if (!string.IsNullOrWhiteSpace(formattedTypeParameterText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedTypeParameterText));
}
}
}
var formattedReturnsText = docCommentFormattingService.Format(docComment.ReturnsText);
if (!string.IsNullOrWhiteSpace(formattedReturnsText))
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_returnsHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedReturnsText));
}
var exceptionTypes = docComment.ExceptionTypes;
if (exceptionTypes.Length > 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_exceptionsHeader);
for (int i = 0; i < exceptionTypes.Length; i++)
{
var rawExceptionTexts = docComment.GetExceptionTexts(exceptionTypes[i]);
for (int j = 0; j < rawExceptionTexts.Length; j++)
{
if (i != 0 || j != 0)
{
formattedCommentLinesBuilder.Add(string.Empty);
}
lineBuilder.Clear();
lineBuilder.Append(' ', s_indentSize);
lineBuilder.Append(string.Format(s_labelFormat, exceptionTypes[i]));
formattedCommentLinesBuilder.Add(lineBuilder.ToString());
var formattedExceptionText = docCommentFormattingService.Format(rawExceptionTexts[j]);
if (!string.IsNullOrWhiteSpace(formattedExceptionText))
{
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedExceptionText));
}
}
}
}
var formattedRemarksText = docCommentFormattingService.Format(docComment.RemarksText);
if (!string.IsNullOrWhiteSpace(formattedRemarksText))
{
formattedCommentLinesBuilder.Add(string.Empty);
formattedCommentLinesBuilder.Add(s_remarksHeader);
formattedCommentLinesBuilder.AddRange(CreateWrappedTextFromRawText(formattedRemarksText));
}
// Eliminate any blank lines at the beginning.
while (formattedCommentLinesBuilder.Count > 0 &&
formattedCommentLinesBuilder[0].Length == 0)
{
formattedCommentLinesBuilder.RemoveAt(0);
}
// Eliminate any blank lines at the end.
while (formattedCommentLinesBuilder.Count > 0 &&
formattedCommentLinesBuilder[formattedCommentLinesBuilder.Count - 1].Length == 0)
{
formattedCommentLinesBuilder.RemoveAt(formattedCommentLinesBuilder.Count - 1);
}
return formattedCommentLinesBuilder.ToImmutable();
}
protected abstract Task <Document> ConvertDocCommentsToRegularCommentsAsync(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken);
public WrappedMethodSymbol(IMethodSymbol methodSymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(methodSymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = methodSymbol;
}
private IDeferredQuickInfoContent GetDocumentationContent(
IEnumerable<ISymbol> symbols,
IDictionary<SymbolDescriptionGroups, ImmutableArray<TaggedText>> sections,
SemanticModel semanticModel,
SyntaxToken token,
IDocumentationCommentFormattingService formatter,
ISyntaxFactsService syntaxFactsService,
CancellationToken cancellationToken)
{
if (sections.ContainsKey(SymbolDescriptionGroups.Documentation))
{
var documentationBuilder = new List<TaggedText>();
documentationBuilder.AddRange(sections[SymbolDescriptionGroups.Documentation]);
return CreateClassifiableDeferredContent(documentationBuilder);
}
else if (symbols.Any())
{
var symbol = symbols.First().OriginalDefinition;
// if generating quick info for an attribute, bind to the class instead of the constructor
if (syntaxFactsService.IsAttributeName(token.Parent) &&
symbol.ContainingType?.IsAttribute() == true)
{
symbol = symbol.ContainingType;
}
var documentation = symbol.GetDocumentationParts(semanticModel, token.SpanStart, formatter, cancellationToken);
if (documentation != null)
{
return CreateClassifiableDeferredContent(documentation.ToList());
}
}
return CreateDocumentationCommentDeferredContent(null);
}
public WrappedEventSymbol(IEventSymbol eventSymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(eventSymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = eventSymbol;
}
private SignatureHelpItem ConvertMethodGroupMethod(
IMethodSymbol method,
InvocationExpressionSyntax invocationExpression,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = invocationExpression.SpanStart;
var item = CreateItem(
method, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
method.IsParams(),
c => method.OriginalDefinition.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, c).Concat(GetAwaitableUsage(method, semanticModel, position)),
GetMethodGroupPreambleParts(method, semanticModel, position),
GetSeparatorParts(),
GetMethodGroupPostambleParts(method),
method.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)));
return item;
}
private static void AddDocumentationPart(List<SymbolDisplayPart> textContentBuilder, ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter, CancellationToken cancellationToken)
{
var documentation = symbol.GetDocumentationParts(semanticModel, position, formatter, cancellationToken);
if (documentation.Any())
{
textContentBuilder.AddLineBreak();
textContentBuilder.AddRange(documentation);
}
}
private SignatureHelpItem Convert(
IMethodSymbol constructor,
ISymbol within,
AttributeSyntax attribute,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormatter,
CancellationToken cancellationToken)
{
var position = attribute.SpanStart;
var namedParameters = constructor.ContainingType.GetAttributeNamedParameters(semanticModel.Compilation, within)
.OrderBy(s => s.Name)
.ToList();
var isVariadic =
constructor.Parameters.Length > 0 && constructor.Parameters.Last().IsParams && namedParameters.Count == 0;
var item = CreateItem(
constructor, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
isVariadic,
constructor.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormatter),
GetPreambleParts(constructor, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(constructor),
GetParameters(constructor, semanticModel, position, namedParameters, documentationCommentFormatter, cancellationToken));
return item;
}
public WrappedFieldSymbol(IFieldSymbol fieldSymbol, IDocumentationCommentFormattingService docCommentFormattingService)
: base(fieldSymbol, canImplementImplicitly: false, docCommentFormattingService: docCommentFormattingService)
{
_symbol = fieldSymbol;
}
private IDeferredQuickInfoContent GetDocumentationContent(
IEnumerable<ISymbol> symbols,
IDictionary<SymbolDescriptionGroups, ImmutableArray<SymbolDisplayPart>> sections,
SemanticModel semanticModel,
int position,
IDocumentationCommentFormattingService formatter,
CancellationToken cancellationToken)
{
if (sections.ContainsKey(SymbolDescriptionGroups.Documentation))
{
var documentationBuilder = new List<SymbolDisplayPart>();
documentationBuilder.AddRange(sections[SymbolDescriptionGroups.Documentation]);
return CreateClassifiableDeferredContent(documentationBuilder);
}
else if (symbols.Any())
{
var symbol = symbols.First().OriginalDefinition;
var documentation = symbol.GetDocumentationParts(semanticModel, position, formatter, cancellationToken);
if (documentation != null)
{
return CreateClassifiableDeferredContent(documentation.ToList());
}
}
return CreateDocumentationCommentDeferredContent(null);
}
public WrappedPropertySymbol(IPropertySymbol propertySymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(propertySymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = propertySymbol;
}
public static Func<CancellationToken, IEnumerable<SymbolDisplayPart>> GetDocumentationPartsFactory(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter)
{
return c => symbol.GetDocumentationParts(semanticModel, position, formatter, cancellationToken: c);
}
private SignatureHelpItem Convert(
IPropertySymbol indexer,
SyntaxToken openToken,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = openToken.SpanStart;
var item = CreateItem(indexer, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
indexer.IsParams(),
indexer.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetPreambleParts(indexer, position, semanticModel),
GetSeparatorParts(),
GetPostambleParts(indexer),
indexer.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)));
return item;
}
private DocCommentConverter(IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
: base(visitIntoStructuredTrivia: false)
{
_formattingService = formattingService;
_cancellationToken = cancellationToken;
}
public WrappedFieldSymbol(IFieldSymbol fieldSymbol, IDocumentationCommentFormattingService docCommentFormattingService)
: base(fieldSymbol, canImplementImplicitly: false, docCommentFormattingService: docCommentFormattingService)
{
_symbol = fieldSymbol;
}
public WrappedPropertySymbol(IPropertySymbol propertySymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(propertySymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = propertySymbol;
}
protected abstract Task<Document> ConvertDocCommentsToRegularComments(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken);
public static SyntaxNode ConvertToRegularComments(SyntaxNode node, IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
{
var converter = new DocCommentConverter(formattingService, cancellationToken);
return converter.Visit(node);
}
public WrappedNamedTypeSymbol(INamedTypeSymbol symbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(symbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = symbol;
var allMembers = _symbol.GetMembers();
var filteredMembers = from m in allMembers
where !m.HasUnsupportedMetadata
where m.DeclaredAccessibility == Accessibility.Public ||
m.DeclaredAccessibility == Accessibility.Protected ||
m.DeclaredAccessibility == Accessibility.ProtectedOrInternal
where m.Kind == SymbolKind.Event ||
m.Kind == SymbolKind.Field ||
m.Kind == SymbolKind.Method ||
m.Kind == SymbolKind.NamedType ||
m.Kind == SymbolKind.Property
select WrapMember(m, canImplementImplicitly, docCommentFormattingService);
_members = ImmutableArray.CreateRange <ISymbol>(filteredMembers);
}
private IList<SignatureHelpSymbolParameter> GetParameters(
IMethodSymbol constructor,
SemanticModel semanticModel,
int position,
IList<ISymbol> namedParameters,
IDocumentationCommentFormattingService documentationCommentFormatter,
CancellationToken cancellationToken)
{
var result = new List<SignatureHelpSymbolParameter>();
foreach (var parameter in constructor.Parameters)
{
result.Add(Convert(parameter, semanticModel, position, documentationCommentFormatter, cancellationToken));
}
for (int i = 0; i < namedParameters.Count; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var namedParameter = namedParameters[i];
var type = namedParameter is IFieldSymbol ? ((IFieldSymbol)namedParameter).Type : ((IPropertySymbol)namedParameter).Type;
var displayParts = new List<SymbolDisplayPart>();
displayParts.Add(new SymbolDisplayPart(
namedParameter is IFieldSymbol ? SymbolDisplayPartKind.FieldName : SymbolDisplayPartKind.PropertyName,
namedParameter, namedParameter.Name.ToIdentifierToken().ToString()));
displayParts.Add(Space());
displayParts.Add(Punctuation(SyntaxKind.EqualsToken));
displayParts.Add(Space());
displayParts.AddRange(type.ToMinimalDisplayParts(semanticModel, position));
result.Add(new SignatureHelpSymbolParameter(
namedParameter.Name,
isOptional: true,
documentationFactory: namedParameter.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormatter),
displayParts: displayParts,
prefixDisplayParts: GetParameterPrefixDisplayParts(i)));
}
return result;
}
public static IEnumerable<SymbolDisplayPart> GetDocumentationParts(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter, CancellationToken cancellationToken)
{
var documentation = symbol.TypeSwitch(
(IParameterSymbol parameter) => parameter.ContainingSymbol.OriginalDefinition.GetDocumentationComment(cancellationToken: cancellationToken).GetParameterText(symbol.Name),
(ITypeParameterSymbol typeParam) => typeParam.ContainingSymbol.GetDocumentationComment(cancellationToken: cancellationToken).GetTypeParameterText(symbol.Name),
(IMethodSymbol method) => GetMethodDocumentation(method),
(IAliasSymbol alias) => alias.Target.GetDocumentationComment(cancellationToken: cancellationToken).SummaryText,
_ => symbol.GetDocumentationComment(cancellationToken: cancellationToken).SummaryText);
return documentation != null
? formatter.Format(documentation, semanticModel, position, CrefFormat)
: SpecializedCollections.EmptyEnumerable<SymbolDisplayPart>();
}
private static ISymbol WrapMember(ISymbol m, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
{
switch (m.Kind)
{
case SymbolKind.Field:
return(new WrappedFieldSymbol((IFieldSymbol)m, docCommentFormattingService));
case SymbolKind.Event:
return(new WrappedEventSymbol((IEventSymbol)m, canImplementImplicitly, docCommentFormattingService));
case SymbolKind.Method:
return(new WrappedMethodSymbol((IMethodSymbol)m, canImplementImplicitly, docCommentFormattingService));
case SymbolKind.NamedType:
return(new WrappedNamedTypeSymbol((INamedTypeSymbol)m, canImplementImplicitly, docCommentFormattingService));
case SymbolKind.Property:
return(new WrappedPropertySymbol((IPropertySymbol)m, canImplementImplicitly, docCommentFormattingService));
}
throw ExceptionUtilities.Unreachable;
}
public static SyntaxNode ConvertToRegularComments(SyntaxNode node, IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
{
var converter = new DocCommentConverter(formattingService, cancellationToken);
return(converter.Visit(node));
}
public static Func <CancellationToken, IEnumerable <SymbolDisplayPart> > GetDocumentationPartsFactory(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter)
{
return(c => symbol.GetDocumentationParts(semanticModel, position, formatter, cancellationToken: c));
}
protected override async Task <Document> ConvertDocCommentsToRegularComments(Document document, IDocumentationCommentFormattingService docCommentFormattingService, CancellationToken cancellationToken)
{
var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newSyntaxRoot = DocCommentConverter.ConvertToRegularComments(syntaxRoot, docCommentFormattingService, cancellationToken);
return(document.WithSyntaxRoot(newSyntaxRoot));
}
public static IEnumerable <TaggedText> GetValueDocumentationParts(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter, CancellationToken cancellationToken)
=> formatter.Format(GetValueDocumentation(symbol.OriginalDefinition, semanticModel.Compilation, cancellationToken),
symbol, semanticModel, position, CrefFormat, cancellationToken);
public static IEnumerable<TaggedText> GetDocumentationParts(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter, CancellationToken cancellationToken)
{
string documentation = GetDocumentation(symbol, cancellationToken);
return documentation != null
? formatter.Format(documentation, semanticModel, position, CrefFormat)
: SpecializedCollections.EmptyEnumerable<TaggedText>();
}
private DocCommentConverter(IDocumentationCommentFormattingService formattingService, CancellationToken cancellationToken)
: base(visitIntoStructuredTrivia: false)
{
_formattingService = formattingService;
_cancellationToken = cancellationToken;
}
public WrappedMethodSymbol(IMethodSymbol methodSymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService)
: base(methodSymbol, canImplementImplicitly, docCommentFormattingService)
{
_symbol = methodSymbol;
}
private SignatureHelpItem Convert(
ISymbol symbol,
SyntaxToken lessThanToken,
SemanticModel semanticModel,
ISymbolDisplayService symbolDisplayService,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
CancellationToken cancellationToken)
{
var position = lessThanToken.SpanStart;
SignatureHelpItem item;
if (symbol is INamedTypeSymbol)
{
var namedType = (INamedTypeSymbol)symbol;
item = CreateItem(
symbol, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
false,
symbol.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetPreambleParts(namedType, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(namedType),
namedType.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
}
else
{
var method = (IMethodSymbol)symbol;
item = CreateItem(
symbol, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
false,
c => symbol.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, c).Concat(GetAwaitableUsage(method, semanticModel, position)),
GetPreambleParts(method, semanticModel, position),
GetSeparatorParts(),
GetPostambleParts(method, semanticModel, position),
method.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList());
}
return item;
}
public static IEnumerable <SymbolDisplayPart> GetDocumentationParts(this ISymbol symbol, SemanticModel semanticModel, int position, IDocumentationCommentFormattingService formatter, CancellationToken cancellationToken)
{
var globalNamespace = semanticModel.Compilation.GlobalNamespace;
var documentation = symbol.TypeSwitch(
(IParameterSymbol parameter) => parameter.ContainingSymbol.OriginalDefinition.GetDocumentationComment(cancellationToken: cancellationToken).GetParameterText(symbol.Name),
(ITypeParameterSymbol typeParam) => typeParam.ContainingSymbol.GetDocumentationComment(cancellationToken: cancellationToken).GetTypeParameterText(symbol.Name),
(IMethodSymbol method) => GetMethodDocumentation(method),
(IAliasSymbol alias) => alias.Target.GetDocumentationComment(cancellationToken: cancellationToken).SummaryText,
_ => symbol.GetDocumentationComment(cancellationToken: cancellationToken).SummaryText);
if (documentation != null)
{
return(formatter.Format(documentation, semanticModel, position, CrefFormat));
}
return(SpecializedCollections.EmptyList <SymbolDisplayPart>());
}
private SignatureHelpSymbolParameter Convert(
ITypeParameterSymbol parameter,
SemanticModel semanticModel,
int position,
IDocumentationCommentFormattingService formatter,
CancellationToken cancellationToken)
{
return new SignatureHelpSymbolParameter(
parameter.Name,
isOptional: false,
documentationFactory: parameter.GetDocumentationPartsFactory(semanticModel, position, formatter),
displayParts: parameter.ToMinimalDisplayParts(semanticModel, position, s_minimallyQualifiedFormat),
selectedDisplayParts: GetSelectedDisplayParts(parameter, semanticModel, position, cancellationToken));
}
