> properties) GetConversionSymbolsAndProperties(
CompletionContext context,
IMethodSymbol conversion
)
{
// If it's a non-synthesized method, then we can just encode it as is.
if (conversion is not CodeGenerationSymbol)
{
return(ImmutableArray.Create <ISymbol>(conversion), ConversionProperties);
}
// Otherwise, encode the constituent parts so we can recover it in GetConversionDescriptionAsync;
var properties = ConversionProperties
.Add(RehydrateName, RehydrateName)
.Add(
DocumentationCommentXmlName,
conversion.GetDocumentationCommentXml(
cancellationToken: context.CancellationToken
) ?? ""
);
var symbols = ImmutableArray.Create <ISymbol>(
conversion.ContainingType,
conversion.Parameters.First().Type,
conversion.ReturnType
);
return(symbols, properties);
}
protected override void ReadSymbol(IMethodSymbol methodSymbol)
{
// we don't need to know about static members
// because they won't be delegated from child to mixin
if (methodSymbol.IsStatic)
return;
// skip methods that are not visible to the outside world
if (methodSymbol.DeclaredAccessibility == Accessibility.Private ||
methodSymbol.DeclaredAccessibility == Accessibility.Protected)
return;
// skip all property accessors and ctors
if (methodSymbol.MethodKind == MethodKind.Ordinary)
{
var isOverrideFromObject =
methodSymbol.IsOverride &&
methodSymbol.OverriddenMethod
?.ContainingType.SpecialType == SpecialType.System_Object;
var method = new Method(
methodSymbol.Name,
methodSymbol.ReturnType,
isOverrideFromObject)
{
IsAbstract = methodSymbol.IsAbstract,
IsOverride = methodSymbol.IsOverride,
IsInternal = methodSymbol.DeclaredAccessibility.HasFlag(Accessibility.Internal),
Documentation = new DocumentationComment(methodSymbol.GetDocumentationCommentXml())
};
var parameterReader = new ParameterSymbolReader(method);
parameterReader.VisitSymbol(methodSymbol);
_methods.AddMethod(method);
}
}
/// <summary>
/// Process a method declaration for documentation.
/// </summary>
/// <param name="symbol">The method in question.</param>
/// <returns><c>Docs</c> if the method contains any, otherwise <c>null</c>.</returns>
public static Doc ForMethod(IMethodSymbol symbol)
{
var doc = symbol.GetDocumentationCommentXml();
if (string.IsNullOrEmpty(doc))
{
return null;
}
var sections = new List<Tuple<int, string, string>>();
var xdoc = XDocument.Parse(doc).Root;
ProcessFull(xdoc, sections);
var cursor = sections.FindIndex(t => t.Item2 == "Summary");
var paramsSection = ProcessParameters(xdoc, symbol.Parameters.Select(p => p.Name).ToList());
sections.Insert(cursor + 1, paramsSection);
var returnElement = xdoc.Element("returns");
if (returnElement != null)
{
var content = ProcessContent(returnElement);
if (!string.IsNullOrEmpty(content))
{
sections.Insert(cursor + 2, Tuple.Create(2, "Return value", $"<p>{content}</p>"));
}
}
var resultString = string.Join("\n", sections.Select(t => $"<h{t.Item1 + 2}>{t.Item2}</h{t.Item1 + 2}>{t.Item3}"));
return new Doc
{
Format = "text/html",
Data = resultString
};
}
private SignatureHelpItem BuildSignature(IMethodSymbol symbol)
{
var signature = new SignatureHelpItem();
signature.Documentation = symbol.GetDocumentationCommentXml();
if (symbol.MethodKind == MethodKind.Constructor)
{
signature.Name = symbol.ContainingType.Name;
signature.Label = symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
}
else
{
signature.Name = symbol.Name;
signature.Label = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
}
signature.Parameters = GetParameters(symbol).Select(parameter =>
{
return(new SignatureHelpParameter()
{
Name = parameter.Name,
Label = parameter.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
Documentation = parameter.GetDocumentationCommentXml()
});
});
return(signature);
}
private IEnumerable <Diagnostic> AnalyzeOverloadsSummaryPhrase(IMethodSymbol symbol, params string[] defaultPhrases)
{
var summaries = GetOverloadSummaries(symbol.GetDocumentationCommentXml());
return(summaries.Any()
? AnalyzeSummaryPhrase(symbol, summaries, defaultPhrases)
: Enumerable.Empty <Diagnostic>());
}
private IEnumerable <Diagnostic> Analyze(SyntaxNodeAnalysisContext context, SyntaxNode methodBody, IMethodSymbol method)
{
var used = methodBody.GetAllUsedVariables(context.SemanticModel);
return(from parameter in method.Parameters
where used.Contains(parameter.Name)
let commentXml = method.GetDocumentationCommentXml()
let comment = parameter.GetComment(commentXml)
where comment.EqualsAny(Phrases, StringComparison.OrdinalIgnoreCase)
select Issue(parameter));
}
private static SignatureHelpItem BuildItem(IMethodSymbol method, SemanticModel model, int position)
{
var item = new SignatureHelpItem
{
Name = method.MethodKind == MethodKind.Constructor ? method.ContainingType.Name : method.Name,
Lable = method.ToMinimalDisplayParts(model, position, SymbolDisplayFormat),
Documentation = method.GetDocumentationCommentXml(),
Parametrs = GetParameters(method).Select(i => new SignatureHelpParametr()
{
Name = i.Name,
Lable = i.ToMinimalDisplayParts(model, position),
Documentation = i.GetDocumentationCommentXml()
})
};
return(item);
}
protected override bool ShallAnalyzeMethod(IMethodSymbol symbol)
{
if (symbol.IsConstructor() is false)
{
return(false);
}
if (IsParameterlessCtor(symbol) ||
IsMessageCtor(symbol) ||
IsMessageExceptionCtor(symbol) ||
symbol.IsSerializationConstructor())
{
return(symbol.GetDocumentationCommentXml().IsNullOrWhiteSpace() is false);
}
return(false); // unknown ctor
}
private static Signature BuildSignature(IMethodSymbol symbol)
{
var signature = new Signature
{
Documentation = symbol.GetDocumentationCommentXml(),
Name = symbol.MethodKind == MethodKind.Constructor ? symbol.ContainingType.Name : symbol.Name,
Label = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
};
signature.Parameters = symbol.Parameters.Select(parameter => new SignatureParameter
{
Name = parameter.Name,
Label = parameter.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
Documentation = parameter.GetDocumentationCommentXml(),
}).ToList();
return(signature);
}
protected override IEnumerable <Diagnostic> AnalyzeMethod(IMethodSymbol method)
{
if (!method.IsEventHandler())
{
return(Enumerable.Empty <Diagnostic>());
}
var xml = method.GetDocumentationCommentXml();
if (xml.IsNullOrWhiteSpace())
{
return(Enumerable.Empty <Diagnostic>());
}
if (xml.Contains("<" + Constants.XmlTag.Inheritdoc))
{
return(Enumerable.Empty <Diagnostic>());
}
return(VerifyParameterComments(method, xml));
}
/// <summary>
/// Process a method declaration for documentation.
/// </summary>
/// <param name="symbol">The method in question.</param>
/// <returns><c>Docs</c> if the method contains any, otherwise <c>null</c>.</returns>
public static Doc ForMethod(IMethodSymbol symbol)
{
try
{
var doc = symbol.GetDocumentationCommentXml();
if (string.IsNullOrEmpty(doc))
{
return(null);
}
var sections = new List <Tuple <int, string, string> >();
var xdoc = XDocument.Parse(doc).Root;
ProcessFull(xdoc, sections);
var cursor = sections.FindIndex(t => t.Item2 == "Summary");
var paramsSection = ProcessParameters(xdoc, symbol.Parameters.Select(p => p.Name).ToList());
sections.Insert(cursor + 1, paramsSection);
var returnElement = xdoc.Element("returns");
if (returnElement != null)
{
var content = ProcessContent(returnElement);
if (!string.IsNullOrEmpty(content))
{
sections.Insert(cursor + 2, Tuple.Create(2, "Return value", $"<p>{content}</p>"));
}
}
var resultString = string.Join("\n", sections.Select(t => $"<h{t.Item1 + 2}>{t.Item2}</h{t.Item1 + 2}>{t.Item3}"));
return(new Doc
{
Format = "text/html",
Data = resultString
});
}
catch (Exception e)
{
return(null);
}
}
private static SignatureHelpItem BuildSignature(IMethodSymbol symbol)
{
var signature = new SignatureHelpItem();
signature.Documentation = symbol.GetDocumentationCommentXml();
signature.Name = symbol.MethodKind == MethodKind.Constructor ? symbol.ContainingType.Name : symbol.Name;
signature.Label = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
signature.StructuredDocumentation = DocumentationConverter.GetStructuredDocumentation(symbol);
signature.Parameters = symbol.Parameters.Select(parameter =>
{
return(new SignatureHelpParameter()
{
Name = parameter.Name,
Label = parameter.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
Documentation = signature.StructuredDocumentation.GetParameterText(parameter.Name)
});
});
return(signature);
}
GetDocumentationComment(IMethodSymbol methodSymbol, bool recurseToParents = true)
{
var comment = methodSymbol.GetDocumentationCommentXml().Trim();
if (string.IsNullOrWhiteSpace(comment) && recurseToParents)
{
foreach (var parentMethod in AllImplementedMethods(methodSymbol))
{
comment = parentMethod.GetDocumentationCommentXml().Trim();
if (!string.IsNullOrWhiteSpace(comment))
{
break;
}
}
}
if (string.IsNullOrWhiteSpace(comment))
{
return("", "", null);
}
if (!comment.StartsWith("<member"))
{
comment = "<member>" + comment + "</member>";
}
var xmlDoc = new XmlDocument();
try
{
xmlDoc.LoadXml(comment);
} catch (Exception)
{
return("", "", null);
}
if (xmlDoc.SelectSingleNode("member") == null)
{
return("", "", null);
}
var memberXmlNode = xmlDoc.SelectSingleNode("member");
string summary = "";
if (memberXmlNode.SelectSingleNode("summary") != null)
{
summary = xmlDoc.SelectSingleNode("member").SelectSingleNode("summary").InnerXml.Trim();
}
var parameterComments = new Dictionary <IParameterSymbol, string>();
var paramNamesToSymbols = methodSymbol.Parameters.ToDictionary(s => s.Name, s => s);
foreach (var paramXmlNode in memberXmlNode.SelectNodes("param"))
{
var paramName = ((XmlNode)paramXmlNode).Attributes["name"].InnerText;
if (paramNamesToSymbols.ContainsKey(paramName))
{
parameterComments.Add(paramNamesToSymbols[paramName], ((XmlNode)paramXmlNode).InnerXml.Trim());
}
}
string returnVal = "";
if (memberXmlNode.SelectSingleNode("returns") != null)
{
returnVal = xmlDoc.SelectSingleNode("member").SelectSingleNode("returns").InnerXml.Trim();
}
return(summary, returnVal, parameterComments);
}
private static SignatureInformation BuildSignature(IMethodSymbol symbol)
{
var parameters = symbol.Parameters
.Select(parameter =>
new ParameterInformation(
label: parameter.Name,
documentation: new FormattedValue("text/markdown", DocumentationConverter.ConvertDocumentation(parameter.GetDocumentationCommentXml(expandIncludes: true)))));
var signatureInformation = new SignatureInformation(
label: symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
documentation: new FormattedValue("text/markdown", DocumentationConverter.ConvertDocumentation(symbol.GetDocumentationCommentXml(expandIncludes: true))),
parameters: parameters.ToList());
return(signatureInformation);
}
GetDocumentationComment(IMethodSymbol methodSymbol)
{
var comment = methodSymbol.GetDocumentationCommentXml().Trim();
if (string.IsNullOrWhiteSpace(comment))
{
return("", "", null);
}
if (!comment.StartsWith("<member"))
{
comment = "<member>" + comment + "</member>";
}
var xmlDoc = new XmlDocument();
try
{
xmlDoc.LoadXml(comment);
} catch (Exception)
{
return("", "", null);
}
if (xmlDoc.SelectSingleNode("member") == null)
{
return("", "", null);
}
var memberXmlNode = xmlDoc.SelectSingleNode("member");
string summary = "";
if (memberXmlNode.SelectSingleNode("summary") != null)
{
summary = xmlDoc.SelectSingleNode("member").SelectSingleNode("summary").InnerXml.Trim();
}
var parameterComments = new Dictionary <IParameterSymbol, string>();
var paramNamesToSymbols = methodSymbol.Parameters.GroupBy(s => s.Name).ToDictionary(s => s.Key, s => s.First());
foreach (var paramXmlNode in memberXmlNode.SelectNodes("param"))
{
var nameNode = ((XmlNode)paramXmlNode).Attributes["name"];
if (nameNode == null)
{
continue;
}
var paramName = nameNode.InnerText;
if (paramNamesToSymbols.ContainsKey(paramName))
{
parameterComments[paramNamesToSymbols[paramName]] = ((XmlNode)paramXmlNode).InnerXml.Trim();
}
}
string returnVal = "";
if (memberXmlNode.SelectSingleNode("returns") != null)
{
returnVal = xmlDoc.SelectSingleNode("member").SelectSingleNode("returns").InnerXml.Trim();
}
return(summary, returnVal, parameterComments);
}
internal static IEnumerable <string> GetOverloadSummaries(this IMethodSymbol symbol) => GetOverloadSummaries(symbol.GetDocumentationCommentXml());
internal static IEnumerable <string> GetValue(this IMethodSymbol symbol) => GetValue(symbol.GetDocumentationCommentXml());
private SignatureHelpItem BuildSignature(IMethodSymbol symbol)
{
var signature = new SignatureHelpItem();
signature.Documentation = symbol.GetDocumentationCommentXml();
if (symbol.MethodKind == MethodKind.Constructor)
{
signature.Name = symbol.ContainingType.Name;
signature.Label = symbol.ContainingType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
}
else
{
signature.Name = symbol.Name;
signature.Label = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
}
signature.Parameters = GetParameters(symbol).Select(parameter =>
{
return new SignatureHelpParameter()
{
Name = parameter.Name,
Label = parameter.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
Documentation = parameter.GetDocumentationCommentXml()
};
});
return signature;
}
private static void ParseMethod(NamedTypeDocumentData parent, IMethodSymbol symbol, string rootName, string id)
{
if (symbol.AssociatedSymbol != null)
{
// We don't want to include methods that are associated with
// events or properties.
return;
}
if (IsNotVisibleInGeneratedDocumentation(symbol))
{
return;
}
var data = CreateDocumentData <MethodDocumentData>(symbol, rootName, id);
DocumentationComment comment = null;
try
{
var commentXml = symbol.GetDocumentationCommentXml();
comment = DocumentationComment.FromXmlFragment(commentXml);
}
catch
{
}
var parameters = symbol.Parameters;
foreach (var parameter in parameters)
{
var parameterData = CreateDocumentData <MethodParameterData>(parameter, null, string.Empty);
parameterData.Summary = comment.GetParameterText(parameterData.Name) ?? string.Empty;
parameterData.Type = CreateDocumentData <DocumentDataObject>(parameter.Type, null, string.Empty);
data.Parameters.Add(parameterData);
}
var typeArguments = symbol.TypeArguments;
foreach (var typeArgument in typeArguments)
{
var typeArgumentData = CreateDocumentData <MethodTypeArgumentData>(typeArgument, null, string.Empty);
data.TypeArguments.Add(typeArgumentData);
}
data.GenerateId();
if (symbol.MethodKind == MethodKind.Constructor || symbol.MethodKind == MethodKind.StaticConstructor)
{
var existingConstructor = parent.GetConstructor(data.Id);
if (existingConstructor == null)
{
data.ReturnType = null;
parent.AddConstructor(data);
}
else
{
existingConstructor.SupportedProjects.Add(id);
}
}
else
{
var existingMethod = parent.GetMethod(data.Id);
if (existingMethod == null)
{
data.ReturnType = CreateDocumentData <DocumentDataObject>(symbol.ReturnType, null, string.Empty);
parent.AddMethod(data);
}
else
{
existingMethod.SupportedProjects.Add(id);
}
}
}
private IMethodSymbol LiftConversion(Compilation compilation, IMethodSymbol method)
=> CreateConversion(
method.ContainingType,
TryMakeNullable(compilation, method.Parameters.Single().Type),
TryMakeNullable(compilation, method.ReturnType),
method.GetDocumentationCommentXml(cancellationToken: _cancellationToken));
/// <summary>
/// Prepares the <see cref="MethodMemberBuilder"/> from the <paramref name="symbol"/>
/// and adds it to <see cref="TypeMemberBuilder.ContentMembers"/>
/// </summary>
/// <param name="symbol">Source <see cref="INamedTypeSymbol"/></param>
/// <param name="root">Builder root</param>
/// <param name="type">Parent <see cref="TypeMemberBuilder"/></param>
/// <param name="level">Hierarchy level (used to indent the console output)</param>
private static void BuildMethod(IMethodSymbol symbol, RootMemberBuilder root, TypeMemberBuilder type, int level)
{
if (symbol.IsImplicitlyDeclared ||
symbol.MethodKind == MethodKind.AnonymousFunction ||
symbol.MethodKind == MethodKind.BuiltinOperator ||
symbol.MethodKind == MethodKind.LambdaMethod ||
symbol.MethodKind == MethodKind.LocalFunction ||
symbol.MethodKind == MethodKind.PropertyGet ||
symbol.MethodKind == MethodKind.PropertySet ||
symbol.MethodKind == MethodKind.EventAdd ||
symbol.MethodKind == MethodKind.EventRemove)
{
return;
}
if (symbol.GetAttributes().Any(a => a.AttributeClassString() == "System.Runtime.CompilerServices.CompilerGeneratedAttribute"))
{
return;
}
var m = new MethodMemberBuilder()
{
Name = symbol.GetOperatorMethodAliasOrOriginalName(),
NameBase = symbol.Name,
OperatorCSharpSymbol = symbol.GetOperatorCSharpSymbol(),
Symbol = symbol,
SourceFiles = symbol.DeclaringSyntaxReferences.Select(dsr => dsr.SyntaxTree.FilePath).ToList(),
DocumentationId = symbol.GetDocumentationCommentId(),
DocumentationXml = symbol.GetDocumentationCommentXml(),
Documentation = Documentation.Read(symbol.GetDocumentationCommentXml()),
Modifier = ModifierEnumExtensions.Modifier(symbol.DeclaredAccessibility),
IsAbstract = symbol.IsAbstract,
IsExtern = symbol.IsExtern,
IsSealed = symbol.IsSealed,
IsStatic = symbol.IsStatic,
IsOverride = symbol.IsOverride,
IsVirtual = symbol.IsVirtual,
IsAsync = symbol.IsAsync,
IsExtensionMethod = symbol.IsExtensionMethod,
IsGeneric = symbol.IsGenericMethod && symbol.TypeParameters != null &&
symbol.TypeParameters.Length > 0,
ReturnsVoid = symbol.ReturnsVoid,
ReturnsByRef = symbol.ReturnsByRef,
ReturnsByRefReadonly = symbol.ReturnsByRefReadonly,
RefKind = (RefKindEnum)symbol.RefKind,
ReturnTypeRef = TypeRef.GetOrCreate(symbol.ReturnType, root),
MethodKind = (MethodKindEnum)symbol.MethodKind,
IsNew = symbol.GetIsNew(),
OverridesSymbol = symbol.OverriddenMethod,
ExplicitInterfaceImplementationMemberSymbol =
symbol.ExplicitInterfaceImplementations != null && symbol.ExplicitInterfaceImplementations.Length > 0
?symbol.ExplicitInterfaceImplementations[0]
:null
};
if (m.IsConstructor || m.IsDestructor)
{
m.Name = $"{(m.IsDestructor ? "~" : "")}{type.Name}";
m.NameBase = m.Name;
}
if (m.IsGeneric)
{
//Process the type parameters
m.TypeParameters = GetTypeParameters(symbol.TypeParameters, root);
m.Name += $"<{string.Join(",", m.TypeParameters.Select(tp => tp.Name))}>"; // add types to name
}
if (symbol.Parameters != null && symbol.Parameters.Length > 0)
{
//Process the method parameters
m.Parameters = GetMethodParameters(symbol.Parameters, root, m.IsExtensionMethod);
m.Name += $"({string.Join(", ", m.Parameters.Select(p => p.TypeRef.ApplySpecialName(false)))})";
}
else
{
m.Name += "()";
}
m.SetAttributes(root);
type.ContentMembers.Add(m);
Console.WriteLine($"{new string(' ', level)} read as {m}");
}
private static Signature BuildSignature(IMethodSymbol symbol)
{
var signature = new Signature();
var docComment = DocumentationComment.From(symbol.GetDocumentationCommentXml(), Environment.NewLine);
var parameterDocumentation = new Dictionary <string, string>();
foreach (var param in docComment.ParamElements)
{
var parts = param.Split(':');
parameterDocumentation.Add(parts[0].Trim(), parts[1].Trim());
}
signature.Description = docComment.SummaryText;
signature.Name = symbol.MethodKind == MethodKind.Constructor ? symbol.ContainingType.Name : symbol.Name;
signature.Label = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
var returnTypeInfo = CheckForStaticExtension.GetReturnType(symbol);
if (returnTypeInfo.HasValue)
{
if (returnTypeInfo.Value.inbuilt)
{
signature.BuiltInReturnType = returnTypeInfo.Value.name;
}
else
{
signature.ReturnType = returnTypeInfo.Value.name;
}
}
signature.Parameters = symbol.Parameters.Select(parameter =>
{
var info = CheckForStaticExtension.GetReturnType(parameter);
var result = new Parameter()
{
Name = parameter.Name,
Label = parameter.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
};
if (parameterDocumentation.ContainsKey(parameter.Name))
{
result.Documentation = parameterDocumentation[parameter.Name];
}
if (info.HasValue)
{
if (info.Value.inbuilt)
{
result.BuiltInType = info.Value.name;
}
else
{
result.BuiltInType = info.Value.name;
}
}
return(result);
}).ToList();
return(signature);
}
protected override IEnumerable <Diagnostic> AnalyzeMethod(IMethodSymbol symbol) => ShallAnalyzeMethod(symbol)
? AnalyzeMethod(symbol, symbol.GetDocumentationCommentXml())
: Enumerable.Empty <Diagnostic>();
