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