public static SyntaxTriviaList Generate(InterfaceDeclarationSyntax interfaceDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (interfaceDeclaration == null)
{
throw new ArgumentNullException(nameof(interfaceDeclaration));
}
return(Generate(
interfaceDeclaration.TypeParameterList,
default(ParameterListSyntax),
generateReturns: false,
settings: settings));
}
public static MemberDeclarationSyntax AddNewDocumentationComment(MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
DocumentationCommentInserter inserter = DocumentationCommentInserter.Create(memberDeclaration);
settings = settings ?? DocumentationCommentGeneratorSettings.Default;
settings = settings.WithIndent(inserter.Indent);
SyntaxTriviaList comment = Generate(memberDeclaration, settings);
SyntaxTriviaList newLeadingTrivia = inserter.InsertRange(comment);
return(memberDeclaration.WithLeadingTrivia(newLeadingTrivia));
}
public static async Task <Document> AddNewDocumentationCommentsAsync(Document document, DocumentationCommentGeneratorSettings settings = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var rewriter = new AddNewDocumentationCommentRewriter(settings);
SyntaxNode newRoot = rewriter.Visit(root);
return(document.WithSyntaxRoot(newRoot));
}
public static SyntaxTriviaList Generate(NamespaceDeclarationSyntax namespaceDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (namespaceDeclaration == null)
{
throw new ArgumentNullException(nameof(namespaceDeclaration));
}
return(Generate(settings: settings));
}
public AddNewDocumentationCommentRewriter(DocumentationCommentGeneratorSettings settings = null, bool skipNamespaceDeclaration = true)
{
Settings = settings ?? DocumentationCommentGeneratorSettings.Default;
SkipNamespaceDeclaration = skipNamespaceDeclaration;
}
public AddBaseOrNewDocumentationCommentRewriter(SemanticModel semanticModel, DocumentationCommentGeneratorSettings settings = null, bool skipNamespaceDeclaration = true, CancellationToken cancellationToken = default)
: base(settings, skipNamespaceDeclaration)
{
SemanticModel = semanticModel;
CancellationToken = cancellationToken;
}
public static SyntaxTriviaList Generate(IndexerDeclarationSyntax indexerDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (indexerDeclaration == null)
{
throw new ArgumentNullException(nameof(indexerDeclaration));
}
return(Generate(
default(TypeParameterListSyntax),
indexerDeclaration.ParameterList,
generateReturns: true,
settings: settings));
}
private static SyntaxTriviaList Generate(
SeparatedSyntaxList <TypeParameterSyntax> typeParameters = default(SeparatedSyntaxList <TypeParameterSyntax>),
SeparatedSyntaxList <ParameterSyntax> parameters = default(SeparatedSyntaxList <ParameterSyntax>),
bool generateReturns = false,
DocumentationCommentGeneratorSettings settings = null)
{
settings = settings ?? DocumentationCommentGeneratorSettings.Default;
ImmutableArray <string> comments = settings.Comments;
var sb = new StringBuilder();
sb.Append(settings.Indent);
sb.Append(@"/// <summary>");
if (settings.SingleLineSummary &&
comments.Length <= 1)
{
if (comments.Length == 1)
{
sb.Append(comments[0]);
}
sb.AppendLine(@"</summary>");
}
else
{
sb.AppendLine();
if (comments.Any())
{
foreach (string comment in comments)
{
sb.Append(settings.Indent);
sb.Append(@"/// ");
sb.AppendLine(comment);
}
}
else
{
sb.Append(settings.Indent);
sb.AppendLine(@"/// ");
}
sb.Append(settings.Indent);
sb.AppendLine(@"/// </summary>");
}
foreach (TypeParameterSyntax typeParameter in typeParameters)
{
sb.Append(settings.Indent);
sb.Append("/// <typeparam name=\"");
sb.Append(typeParameter.Identifier.ValueText);
sb.AppendLine("\"></typeparam>");
}
foreach (ParameterSyntax parameter in parameters)
{
sb.Append(settings.Indent);
sb.Append("/// <param name=\"");
sb.Append(parameter.Identifier.ValueText);
sb.AppendLine("\"></param>");
}
if (generateReturns &&
settings.GenerateReturns)
{
sb.Append(settings.Indent);
sb.AppendLine("/// <returns></returns>");
}
return(SyntaxFactory.ParseLeadingTrivia(sb.ToString()));
}
public static SyntaxTriviaList Generate(MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
switch (memberDeclaration.Kind())
{
case SyntaxKind.NamespaceDeclaration:
return(Generate((NamespaceDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ClassDeclaration:
return(Generate((ClassDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.StructDeclaration:
return(Generate((StructDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.InterfaceDeclaration:
return(Generate((InterfaceDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EnumDeclaration:
return(Generate((EnumDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.DelegateDeclaration:
return(Generate((DelegateDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EnumMemberDeclaration:
return(Generate((EnumMemberDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.FieldDeclaration:
return(Generate((FieldDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EventFieldDeclaration:
return(Generate((EventFieldDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.MethodDeclaration:
return(Generate((MethodDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.OperatorDeclaration:
return(Generate((OperatorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ConversionOperatorDeclaration:
return(Generate((ConversionOperatorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ConstructorDeclaration:
return(Generate((ConstructorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.DestructorDeclaration:
return(Generate((DestructorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.PropertyDeclaration:
return(Generate((PropertyDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EventDeclaration:
return(Generate((EventDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.IndexerDeclaration:
return(Generate((IndexerDeclarationSyntax)memberDeclaration, settings));
default:
throw new ArgumentException("", nameof(memberDeclaration));
}
}
public static SyntaxTriviaList Generate(ConversionOperatorDeclarationSyntax conversionOperatorDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (conversionOperatorDeclaration == null)
{
throw new ArgumentNullException(nameof(conversionOperatorDeclaration));
}
return(Generate(
default(TypeParameterListSyntax),
conversionOperatorDeclaration.ParameterList,
generateReturns: false,
settings: settings));
}
public static SyntaxTriviaList Generate(MethodDeclarationSyntax methodDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (methodDeclaration == null)
{
throw new ArgumentNullException(nameof(methodDeclaration));
}
return(Generate(
methodDeclaration.TypeParameterList,
methodDeclaration.ParameterList,
generateReturns: !methodDeclaration.ReturnsVoid(),
settings: settings));
}
public static SyntaxTriviaList Generate(DelegateDeclarationSyntax delegateDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (delegateDeclaration == null)
{
throw new ArgumentNullException(nameof(delegateDeclaration));
}
return(Generate(
delegateDeclaration.TypeParameterList,
delegateDeclaration.ParameterList,
generateReturns: false,
settings: settings));
}
private static SyntaxTriviaList Generate(
SeparatedSyntaxList <TypeParameterSyntax> typeParameters = default(SeparatedSyntaxList <TypeParameterSyntax>),
SeparatedSyntaxList <ParameterSyntax> parameters = default(SeparatedSyntaxList <ParameterSyntax>),
bool canGenerateReturns = false,
DocumentationCommentGeneratorSettings settings = null)
{
settings = settings ?? DocumentationCommentGeneratorSettings.Default;
ImmutableArray <string> summary = settings.Summary;
StringBuilder sb = StringBuilderCache.GetInstance();
sb.Append(settings.Indentation);
sb.Append("/// <summary>");
if (settings.SingleLineSummary &&
summary.Length <= 1)
{
if (summary.Length == 1)
{
sb.Append(summary[0]);
}
sb.AppendLine("</summary>");
}
else
{
sb.AppendLine();
if (summary.Any())
{
foreach (string comment in summary)
{
sb.Append(settings.Indentation);
sb.Append("/// ");
sb.AppendLine(comment);
}
}
else
{
sb.Append(settings.Indentation);
sb.AppendLine("/// ");
}
sb.Append(settings.Indentation);
sb.AppendLine("/// </summary>");
}
foreach (TypeParameterSyntax typeParameter in typeParameters)
{
sb.Append(settings.Indentation);
sb.Append("/// <typeparam name=\"");
sb.Append(typeParameter.Identifier.ValueText);
sb.AppendLine("\"></typeparam>");
}
foreach (ParameterSyntax parameter in parameters)
{
sb.Append(settings.Indentation);
sb.Append("/// <param name=\"");
sb.Append(parameter.Identifier.ValueText);
sb.AppendLine("\"></param>");
}
if (canGenerateReturns &&
settings.Returns)
{
sb.Append(settings.Indentation);
sb.AppendLine("/// <returns></returns>");
}
return(SyntaxFactory.ParseLeadingTrivia(StringBuilderCache.GetStringAndFree(sb)));
}
public AddBaseOrNewDocumentationCommentRewriter(DocumentationCommentGeneratorSettings settings, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken))
: base(settings)
{
SemanticModel = semanticModel;
CancellationToken = cancellationToken;
}
public AddNewDocumentationCommentRewriter(DocumentationCommentGeneratorSettings settings)
{
Settings = settings ?? DocumentationCommentGeneratorSettings.Default;
}
