public bool TryGetSorted(SyntaxNode node, out MemberDeclarationSyntax sortedNode)
{
sortedNode = null;
var member = node as MemberDeclarationSyntax;
if (member == null || member is TypeDeclarationSyntax || member is NamespaceDeclarationSyntax)
{
return(false);
}
var type = member.FirstAncestorOrSelf <TypeDeclarationSyntax>();
if (type == null)
{
return(false);
}
if (this.sorted.Item.TryGetValue(type, out List <MemberDeclarationSyntax> sortedMembers))
{
var index = type.Members.IndexOf(member);
if (index == -1)
{
return(false);
}
sortedNode = sortedMembers[index];
if (index == 0)
{
if (sortedNode.HasLeadingTrivia)
{
var leadingTrivia = sortedNode.GetLeadingTrivia();
if (leadingTrivia.Any() &&
leadingTrivia[0].IsKind(SyntaxKind.EndOfLineTrivia))
{
sortedNode = sortedNode.WithLeadingTrivia(leadingTrivia.RemoveAt(0));
}
}
}
else if (!(sortedNode is FieldDeclarationSyntax))
{
if (sortedNode.HasLeadingTrivia)
{
var leadingTrivia = sortedNode.GetLeadingTrivia();
if (!leadingTrivia[0].IsKind(SyntaxKind.EndOfLineTrivia))
{
sortedNode = sortedNode.WithLeadingTrivia(leadingTrivia.Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine)));
}
}
else
{
sortedNode = sortedNode.WithLeadingTrivia(SyntaxTriviaList.Create(SyntaxFactory.EndOfLine(Environment.NewLine)));
}
}
return(true);
}
return(true);
}
private static SyntaxNode RemoveNode(MemberDeclarationSyntax member)
{
MemberDeclarationListInfo memberList = SyntaxInfo.MemberDeclarationListInfo(member.Parent);
SyntaxList <MemberDeclarationSyntax> members = memberList.Members;
MemberDeclarationListInfo newMemberList = memberList.RemoveNode(member, SyntaxRemoveOptions.KeepUnbalancedDirectives);
int index = members.IndexOf(member);
if (index == 0 &&
index < members.Count - 1)
{
MemberDeclarationSyntax nextMember = newMemberList[index];
SyntaxTriviaList leadingTrivia = nextMember.GetLeadingTrivia();
if (leadingTrivia.FirstOrDefault().IsEndOfLineTrivia())
{
MemberDeclarationSyntax newNextMember = nextMember.WithLeadingTrivia(leadingTrivia.RemoveAt(0));
newMemberList = newMemberList.ReplaceNode(nextMember, newNextMember);
}
}
return(newMemberList.Parent);
}
internal static MemberDeclarationSyntax RemoveSingleLineDocumentationComment(MemberDeclarationSyntax declaration)
{
if (declaration == null)
{
throw new ArgumentNullException(nameof(declaration));
}
SyntaxTriviaList leadingTrivia = declaration.GetLeadingTrivia();
SyntaxTriviaList.Reversed.Enumerator en = leadingTrivia.Reverse().GetEnumerator();
int i = 0;
while (en.MoveNext())
{
SyntaxKind kind = en.Current.Kind();
if (kind == SyntaxKind.WhitespaceTrivia ||
kind == SyntaxKind.EndOfLineTrivia)
{
i++;
}
else if (kind == SyntaxKind.SingleLineDocumentationCommentTrivia)
{
return(declaration.WithLeadingTrivia(leadingTrivia.Take(leadingTrivia.Count - (i + 1))));
}
else
{
return(declaration);
}
}
return(declaration);
}
private static T RemoveNode <T>(
T declaration,
Func <T, SyntaxList <MemberDeclarationSyntax> > getMembers,
int index,
SyntaxRemoveOptions removeOptions) where T : SyntaxNode
{
SyntaxList <MemberDeclarationSyntax> members = getMembers(declaration);
T newDeclaration = declaration.RemoveNode(members[index], removeOptions);
if (index == 0 &&
index < members.Count - 1)
{
members = getMembers(newDeclaration);
MemberDeclarationSyntax nextMember = members[index];
SyntaxTriviaList leadingTrivia = nextMember.GetLeadingTrivia();
SyntaxTrivia trivia = leadingTrivia.FirstOrDefault();
if (trivia.IsEndOfLineTrivia())
{
MemberDeclarationSyntax newNextMember = nextMember.WithLeadingTrivia(leadingTrivia.RemoveAt(0));
newDeclaration = newDeclaration.ReplaceNode(nextMember, newNextMember);
}
}
return(newDeclaration);
}
public static async Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax member,
CancellationToken cancellationToken = default)
{
MemberDeclarationSyntax newMember = member;
SyntaxToken identifier = GetIdentifier(member);
if (identifier != default)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string newName = NameGenerator.Default.EnsureUniqueName(identifier.ValueText, semanticModel, member.SpanStart);
ISymbol symbol = semanticModel.GetDeclaredSymbol(member, cancellationToken);
ImmutableArray <SyntaxNode> references = await SyntaxFinder.FindReferencesAsync(symbol, document.Solution(), documents : ImmutableHashSet.Create(document), cancellationToken : cancellationToken).ConfigureAwait(false);
SyntaxToken newIdentifier = SyntaxFactory.Identifier(newName);
newMember = member.ReplaceNodes(
references.Where(n => member.Contains(n)),
(n, _) =>
{
if (n is IdentifierNameSyntax identifierName)
{
return(identifierName.WithIdentifier(newIdentifier.WithTriviaFrom(identifierName.Identifier)));
}
else
{
Debug.Fail(n.Kind().ToString());
return(n);
}
});
newMember = SetIdentifier(newMember, newIdentifier.WithRenameAnnotation());
}
else
{
newMember = newMember.WithNavigationAnnotation();
}
MemberDeclarationListInfo memberList = SyntaxInfo.MemberDeclarationListInfo(member.Parent);
int index = memberList.IndexOf(member);
if (index == 0)
{
SyntaxToken?openBrace = memberList.OpenBraceToken;
if (openBrace != null &&
openBrace.Value.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
newMember = newMember.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLine()));
}
}
return(await document.ReplaceMembersAsync(memberList, memberList.Members.Insert(index + 1, newMember), cancellationToken).ConfigureAwait(false));
}
private static void AnalyzeCompilationUnit(SyntaxNodeAnalysisContext context)
{
var compilationUnit = (CompilationUnitSyntax)context.Node;
MemberDeclarationSyntax declaration = compilationUnit.Members.FirstOrDefault();
if (declaration == null)
{
return;
}
if (!SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(declaration.GetLeadingTrivia()))
{
return;
}
SyntaxNode node = compilationUnit.AttributeLists.LastOrDefault()
?? (SyntaxNode)compilationUnit.Usings.LastOrDefault()
?? compilationUnit.Externs.LastOrDefault();
if (node == null)
{
return;
}
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(node.GetTrailingTrivia()))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBeforeTopDeclaration,
Location.Create(compilationUnit.SyntaxTree, new TextSpan(node.GetTrailingTrivia().Last().SpanStart, 0)));
}
private SyntaxNode AddDescription(SyntaxNode rootNode, MemberDeclarationSyntax memberDeclaration,
string description, CancellationToken cancellation)
{
cancellation.ThrowIfCancellationRequested();
var summaryTag = memberDeclaration
.GetLeadingTrivia()
.Select(t => t.GetStructure())
.OfType <DocumentationCommentTriviaSyntax>()
.SelectMany(d => d.ChildNodes())
.OfType <XmlElementSyntax>()
.First(n => XmlCommentSummaryTag.Equals(n.StartTag?.Name?.ToString(), StringComparison.Ordinal));
var xmlDescription = new[]
{
XmlText(
XmlTextNewLine(Environment.NewLine, true)
),
XmlText(
XmlTextNewLine(description + Environment.NewLine, true)
)
};
var newContent = new SyntaxList <XmlNodeSyntax>(xmlDescription);
var newSummaryTag = summaryTag
.WithContent(newContent)
.WithAdditionalAnnotations(Formatter.Annotation);
return(rootNode.ReplaceNode(summaryTag, newSummaryTag));
}
internal static MemberDeclarationSyntax RemoveSingleLineDocumentationComment(MemberDeclarationSyntax member)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
SyntaxTriviaList leadingTrivia = member.GetLeadingTrivia();
SyntaxTriviaList.Reversed.Enumerator en = leadingTrivia.Reverse().GetEnumerator();
int i = 0;
while (en.MoveNext())
{
if (en.Current.IsWhitespaceOrEndOfLineTrivia())
{
i++;
}
else if (en.Current.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia))
{
return(member.WithLeadingTrivia(leadingTrivia.Take(leadingTrivia.Count - (i + 1))));
}
else
{
return(member);
}
}
return(member);
}
internal static IEnumerable <CrefSyntax> GetDocumentedExceptions(this MemberDeclarationSyntax @this)
{
return(@this
.GetLeadingTrivia()
.Select(trivia => trivia.GetStructure())
.OfType <DocumentationCommentTriviaSyntax>()
.SelectMany(GetDocumentedExceptions));
}
private static async Task <Document> DocumentExceptionsAsync(Document document, MemberDeclarationSyntax declaration, ImmutableArray <String> exceptions)
{
SyntaxNode?root = await document.GetSyntaxRootAsync();
if (root is null)
{
// ?!
return(document);
}
DocumentationCommentTriviaSyntax?documentation = declaration
.GetLeadingTrivia()
.Select(trivia => trivia.GetStructure())
.OfType <DocumentationCommentTriviaSyntax>()
.FirstOrDefault();
DocumentOptionSet options = await document.GetOptionsAsync();
if (documentation is null)
{
root = root.ReplaceNode(
declaration,
declaration.WithLeadingTrivia(
declaration
.GetLeadingTrivia()
.Add(Trivia(DocumentationComment(ExceptionDocumentation(options, exceptions))))
)
);
}
else
{
//
// TODO: remove duplicates and subtypes that are handled by base types
//
root = root.ReplaceNode(
documentation,
documentation.AddContent(ExceptionDocumentation(options, exceptions))
);
}
return(document.WithSyntaxRoot(root));
}
private SyntaxNode AddDocumentationTrivia(SyntaxNode rootNode, MemberDeclarationSyntax memberDeclaration,
SyntaxTrivia documentationTrivia, CancellationToken cancellation)
{
cancellation.ThrowIfCancellationRequested();
var newTrivia = memberDeclaration.GetLeadingTrivia().Add(documentationTrivia);
var newClassDeclarationSyntax = memberDeclaration.WithLeadingTrivia(newTrivia);
return(rootNode.ReplaceNode(memberDeclaration, newClassDeclarationSyntax));
}
public static Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax declaration,
TextSpan span,
CancellationToken cancellationToken)
{
MemberDeclarationSyntax newDeclaration = declaration;
ImmutableArray <string> comments;
SyntaxTriviaList leadingTrivia = declaration.GetLeadingTrivia();
if (leadingTrivia.Span.Contains(span))
{
comments = leadingTrivia
.Where(f => span.Contains(f.Span) && f.Kind() == SyntaxKind.SingleLineCommentTrivia)
.Select(f => _leadingSlashesRegex.Replace(f.ToString(), ""))
.ToImmutableArray();
TextSpan spanToRemove = TextSpan.FromBounds(span.Start, declaration.SpanStart);
newDeclaration = declaration.WithLeadingTrivia(leadingTrivia.Where(f => !spanToRemove.Contains(f.Span)));
}
else
{
SyntaxTrivia trivia = declaration.FindTrivia(span.Start);
Debug.Assert(trivia != default(SyntaxTrivia));
SyntaxToken token = trivia.Token;
SyntaxTriviaList trailingTrivia = token.TrailingTrivia;
Debug.Assert(trailingTrivia.Contains(trivia));
for (int i = 0; i < trailingTrivia.Count; i++)
{
if (trailingTrivia[i].Span == span)
{
comments = ImmutableArray.Create(_leadingSlashesRegex.Replace(trailingTrivia[i].ToString(), ""));
SyntaxToken newToken = token.WithTrailingTrivia(trailingTrivia.Skip(i + 1));
newDeclaration = newDeclaration.ReplaceToken(token, newToken);
break;
}
}
}
var settings = new DocumentationCommentGeneratorSettings(comments);
newDeclaration = newDeclaration.WithNewSingleLineDocumentationComment(settings);
return(document.ReplaceNodeAsync(declaration, newDeclaration, cancellationToken));
}
public static bool HasSingleLineDocumentationComment(this MemberDeclarationSyntax memberDeclaration)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
return(memberDeclaration
.GetLeadingTrivia()
.Any(f => f.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia)));
}
/// <summary>
/// Get the leading <see cref="SyntaxKind.EndOfLineTrivia"/> if exists.
/// </summary>
/// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param>
/// <param name="trivia">The <see cref="SyntaxTrivia"/>.</param>
/// <returns>True if leading <see cref="SyntaxKind.WhitespaceTrivia"/> exists.</returns>
public static bool TryGetLeadingWhitespace(this MemberDeclarationSyntax member, out SyntaxTrivia trivia)
{
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
trivia = default;
return(member.HasLeadingTrivia &&
member.GetLeadingTrivia() is { } triviaList&&
triviaList.TryFirst(x => x.IsKind(SyntaxKind.WhitespaceTrivia), out trivia));
}
private static async Task <Document> RemoveSerializeFieldAttributeAsync(Document document, MemberDeclarationSyntax declaration, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var attributes = new SyntaxList <AttributeListSyntax>();
foreach (var attributeList in declaration.AttributeLists)
{
var nodes = new List <AttributeSyntax>();
foreach (var node in attributeList.Attributes)
{
var attributeType = model.GetTypeInfo(node).Type;
if (attributeType == null)
{
continue;
}
if (attributeType.Matches(typeof(UnityEngine.SerializeField)))
{
nodes.Add(node);
}
}
if (nodes.Any())
{
var newAttributes = attributeList.RemoveNodes(nodes, SyntaxRemoveOptions.KeepNoTrivia);
if (newAttributes.Attributes.Any())
{
attributes = attributes.Add(newAttributes);
}
}
else
{
attributes = attributes.Add(attributeList);
}
}
var newDeclaration = declaration
.WithAttributeLists(attributes)
.WithLeadingTrivia(declaration.GetLeadingTrivia());
var newRoot = root.ReplaceNode(declaration, newDeclaration);
if (newRoot == null)
{
return(document);
}
return(document.WithSyntaxRoot(newRoot));
}
internal static SyntaxRemoveOptions GetRemoveOptions(MemberDeclarationSyntax newMember)
{
SyntaxRemoveOptions removeOptions = DefaultRemoveOptions;
if (newMember.GetLeadingTrivia().IsWhitespaceOrEndOfLine())
{
removeOptions &= ~SyntaxRemoveOptions.KeepLeadingTrivia;
}
if (newMember.GetTrailingTrivia().IsWhitespaceOrEndOfLine())
{
removeOptions &= ~SyntaxRemoveOptions.KeepTrailingTrivia;
}
return(removeOptions);
}
public static async Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax memberDeclaration,
SyntaxTrivia commentTrivia,
CancellationToken cancellationToken)
{
SyntaxTriviaList leadingTrivia = memberDeclaration.GetLeadingTrivia();
SyntaxTriviaList newLeadingTrivia = InsertDocumentationCommentTrivia(leadingTrivia, commentTrivia);
MemberDeclarationSyntax newMemberDeclaration = memberDeclaration
.WithLeadingTrivia(newLeadingTrivia)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(memberDeclaration, newMemberDeclaration, cancellationToken).ConfigureAwait(false));
}
private static SyntaxNode AddAccessModifierIfNotPresent(MemberDeclarationSyntax node)
{
SyntaxTokenList modifiers = node.Modifiers;
AccessModifier currentAccessibility = ModifiersHelper.GetAccessibility(modifiers);
if (currentAccessibility != AccessModifier.NotExplicit)
{
return(node);
}
AccessModifier defaultAccessibility = ModifiersHelper.GetDefaultAccessibility(node.Kind());
SyntaxTriviaList leadingTrivia = node.GetLeadingTrivia();
SyntaxTokenList newModifiers = FormatModifiers(modifiers, defaultAccessibility);
return(node.WithoutLeadingTrivia().WithModifiers(newModifiers).WithLeadingTrivia(leadingTrivia));
}
/// <summary>
/// Get the leading <see cref="SyntaxKind.EndOfLineTrivia"/> if exists.
/// </summary>
/// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param>
/// <param name="trivia">The <see cref="SyntaxTriviaList"/>.</param>
/// <returns>True if leading <see cref="SyntaxKind.EndOfLineTrivia"/> exists.</returns>
public static bool TryGetLeadingTrivia(this MemberDeclarationSyntax member, out SyntaxTriviaList trivia)
{
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
if (member.HasLeadingTrivia)
{
trivia = member.GetLeadingTrivia();
return(true);
}
trivia = default;
return(false);
}
private static SyntaxRemoveOptions GetMemberRemoveOptions(MemberDeclarationSyntax member)
{
SyntaxRemoveOptions removeOptions = DefaultMemberRemoveOptions;
if (member.GetLeadingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
removeOptions &= ~SyntaxRemoveOptions.KeepLeadingTrivia;
}
if (member.GetTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
removeOptions &= ~SyntaxRemoveOptions.KeepTrailingTrivia;
}
return(removeOptions);
}
private static async Task <Document> RefactorAsync(
Document document,
SyntaxTrivia trivia,
ThrowInfo throwInfo,
MemberDeclarationSyntax memberDeclaration,
ISymbol declarationSymbol,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
SourceText sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var throwInfos = new List <ThrowInfo>()
{
throwInfo
};
INamedTypeSymbol exceptionSymbol = semanticModel.GetTypeByMetadataName("System.Exception");
foreach (ThrowInfo info in GetOtherUndocumentedExceptions(memberDeclaration, declarationSymbol, node => node != throwInfo.Node, exceptionSymbol, semanticModel, cancellationToken))
{
if (!throwInfos.Any(f => f.ExceptionSymbol == info.ExceptionSymbol))
{
throwInfos.Add(info);
}
}
string indent = GetIndent(memberDeclaration.GetLeadingTrivia());
StringBuilder sb = StringBuilderCache.GetInstance();
foreach (ThrowInfo info in throwInfos)
{
sb.Append(indent);
IParameterSymbol parameterSymbol = info.GetParameterSymbol(semanticModel, cancellationToken);
AppendExceptionDocumentation(trivia, info.ExceptionSymbol, parameterSymbol, semanticModel, ref sb);
}
string newText = StringBuilderCache.GetStringAndFree(sb);
var textChange = new TextChange(new TextSpan(trivia.FullSpan.End, 0), newText);
SourceText newSourceText = sourceText.WithChanges(textChange);
return(document.WithText(newSourceText));
}
private void MoveInitialTrivia(ref FieldDeclarationSyntax newField, ref MemberDeclarationSyntax newDeclaration)
{
var leadingTrivia = newDeclaration.GetLeadingTrivia();
if (!leadingTrivia.Any())
{
return;
}
var last = leadingTrivia.Last();
if (leadingTrivia.Any() && (SyntaxKind)last.RawKind == SyntaxKind.WhitespaceTrivia)
{
newField = newField.WithLeadingTrivia(leadingTrivia);
newDeclaration = newDeclaration.WithLeadingTrivia(last);
}
}
private static FileLinePositionSpan GetFileLinePositionSpan(MemberDeclarationSyntax member, CancellationToken cancellationToken)
{
SyntaxTrivia trivia = member
.GetLeadingTrivia()
.Reverse()
.SkipWhile(f => f.IsWhitespaceOrEndOfLineTrivia())
.FirstOrDefault();
if (trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia))
{
TextSpan span = TextSpan.FromBounds(trivia.Span.Start, member.Span.End);
return(member.SyntaxTree.GetLineSpan(span, cancellationToken));
}
else
{
return(member.SyntaxTree.GetLineSpan(member.Span, cancellationToken));
}
}
/// <summary>
/// Get the <see cref="DocumentationCommentTriviaSyntax"/> for the accessor if it exists.
/// </summary>
/// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param>
/// <param name="comment">The returned <see cref="DocumentationCommentTriviaSyntax"/>.</param>
/// <returns>True if a single <see cref="DocumentationCommentTriviaSyntax"/> was found.</returns>
public static bool TryGetDocumentationComment(this MemberDeclarationSyntax member, [NotNullWhen(true)] out DocumentationCommentTriviaSyntax?comment)
{
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
if (member.HasLeadingTrivia &&
member.GetLeadingTrivia() is { } triviaList&&
triviaList.TrySingle(x => x.HasStructure && x.GetStructure() is DocumentationCommentTriviaSyntax, out var commentTrivia) &&
commentTrivia.GetStructure() is DocumentationCommentTriviaSyntax triviaSyntax)
{
comment = triviaSyntax;
return(true);
}
comment = null;
return(false);
}
private static Task <Document> RefactorAsync(
Document document,
SyntaxTrivia trivia,
ThrowInfo throwInfo,
MemberDeclarationSyntax memberDeclaration,
ISymbol declarationSymbol,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var throwInfos = new List <ThrowInfo>()
{
throwInfo
};
INamedTypeSymbol exceptionSymbol = semanticModel.GetTypeByMetadataName("System.Exception");
foreach (ThrowInfo info in GetOtherUndocumentedExceptions(memberDeclaration, declarationSymbol, node => node != throwInfo.Node, exceptionSymbol, semanticModel, cancellationToken))
{
if (!throwInfos.Any(f => SymbolEqualityComparer.Default.Equals(f.ExceptionSymbol, info.ExceptionSymbol)))
{
throwInfos.Add(info);
}
}
string indent = GetIndent(memberDeclaration.GetLeadingTrivia());
StringBuilder sb = StringBuilderCache.GetInstance();
foreach (ThrowInfo info in throwInfos)
{
sb.Append(indent);
IParameterSymbol parameterSymbol = info.GetParameterSymbol(semanticModel, cancellationToken);
AppendExceptionDocumentation(trivia, info.ExceptionSymbol, parameterSymbol, semanticModel, ref sb);
}
return(document.WithTextChangeAsync(
new TextSpan(trivia.FullSpan.End, 0),
StringBuilderCache.GetStringAndFree(sb),
cancellationToken));
}
public static MemberDeclarationSyntax GenerateAndAttach(MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
SyntaxTriviaList leadingTrivia = memberDeclaration.GetLeadingTrivia();
int index = 0;
string indent = "";
if (leadingTrivia.Any())
{
index = leadingTrivia.Count - 1;
for (int i = leadingTrivia.Count - 1; i >= 0; i--)
{
if (leadingTrivia[i].IsWhitespaceTrivia())
{
index = i;
}
else
{
break;
}
}
indent = string.Concat(leadingTrivia.Skip(index));
}
settings = settings ?? DocumentationCommentGeneratorSettings.Default;
settings = settings.WithIndent(indent);
SyntaxTriviaList comment = Generate(memberDeclaration, settings);
SyntaxTriviaList newLeadingTrivia = leadingTrivia.InsertRange(index, comment);
return(memberDeclaration.WithLeadingTrivia(newLeadingTrivia));
}
MemberDeclarationSyntax ApplyNodeChange(MemberDeclarationSyntax statementNode)
{
var leadingTriviaList = statementNode.GetLeadingTrivia();
bool isCleanupDone = false;
if (_LastMember is MethodDeclarationSyntax && IsStartWithSpecialDirective(leadingTriviaList) == false)
{
if (CheckOption((int)CleanupTypes.Adding_Blank_after_Method_Close_Bracket))
{
if (leadingTriviaList.Count(x => x.IsKind(SyntaxKind.EndOfLineTrivia)) < 2)
{
leadingTriviaList = CleanUpListWithExactNumberOfWhitespaces(leadingTriviaList, 1, null);
isCleanupDone = true;
}
}
else if (CheckOption((int)CleanupTypes.Remove_DBL_Between_Class_Members))
{
leadingTriviaList = CleanUpListWithDefaultWhitespaces(leadingTriviaList, null);
isCleanupDone = true;
}
}
else if (CheckOption((int)CleanupTypes.Remove_DBL_Between_Class_Members))
{
leadingTriviaList = CleanUpListWithDefaultWhitespaces(leadingTriviaList, null);
isCleanupDone = true;
}
if (!isCleanupDone)
{
leadingTriviaList = ProcessSpecialTrivias(leadingTriviaList, false);
}
statementNode = statementNode.WithLeadingTrivia(leadingTriviaList);
_LastMember = statementNode;
return(statementNode);
}
private static MemberDeclarationSyntax ChangeAccessibilityModifiersInDeclaration(MemberDeclarationSyntax declaration, SyntaxTokenList newAccessibilityModifiers)
{
var newDeclaration = declaration;
var actualTypeAccessibilityModifiers = GetAccessibilityModifiersFromMember(declaration);
var hasAccessibilityModifiers = actualTypeAccessibilityModifiers.Any();
var leadingTrivias = default(SyntaxTriviaList);
var trailingTrivias = default(SyntaxTriviaList);
if (!hasAccessibilityModifiers)
{
var modifiers = declaration.GetModifiers();
if (modifiers.Any())
{
var firstModifier = modifiers.First();
leadingTrivias = firstModifier.LeadingTrivia;
newDeclaration = RemoveLeadingTriviasFromFirstDeclarationModifier(declaration, modifiers, firstModifier);
}
else
{
leadingTrivias = declaration.GetLeadingTrivia();
newDeclaration = RemoveLeadingTriviasFromDeclaration(declaration);
}
trailingTrivias = SyntaxFactory.TriviaList(SyntaxFactory.Space);
}
else
{
leadingTrivias = actualTypeAccessibilityModifiers.First().LeadingTrivia;
trailingTrivias = GetAllTriviasAfterFirstModifier(actualTypeAccessibilityModifiers);
}
newAccessibilityModifiers = MergeActualTriviasIntoNewAccessibilityModifiers(newAccessibilityModifiers, leadingTrivias, trailingTrivias);
newDeclaration = ReplaceDeclarationModifiers(newDeclaration, actualTypeAccessibilityModifiers.ToList(), newAccessibilityModifiers);
return(newDeclaration);
}
MemberDeclarationSyntax ApplyNodeChange(MemberDeclarationSyntax statementNode)
{
var triviList = statementNode.GetLeadingTrivia();
var zeroCondition = _lastTokenIsAOpenBrace || _lastToken == default(SyntaxToken);
if (zeroCondition)
{
triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 0);
}
else if (_lastTokenIsACloseBrace && IsStartWithSpecialDirective(triviList) == false)
{
triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 1, itsForCloseBrace: false);
}
else
{
triviList = CleanUpListWithDefaultWhitespaces(triviList);
}
statementNode = statementNode.WithLeadingTrivia(triviList);
return(statementNode);
}
public static MemberDeclarationSyntax UpdateModifiers(this MemberDeclarationSyntax member, ModifierFlags flags)
{
// The starting token for this member may change, so we need to save
// the leading trivia and reattach it after updating the modifiers.
// We also need to remove it here to avoid duplicates.
var leadingTrivia = member.GetLeadingTrivia();
member = member.WithLeadingTrivia(SyntaxTriviaList.Empty);
var newModifierList = new List <SyntaxToken>();
foreach (var modifierDefinition in s_modifierDefinitions)
{
if ((flags & modifierDefinition.Key) != 0)
{
newModifierList.Add(SyntaxFactory.Token(modifierDefinition.Value));
}
}
var newMember = member.WithModifiers(SyntaxFactory.TokenList(newModifierList));
return(newMember.WithLeadingTrivia(leadingTrivia));
}
private static DocumentationCommentTriviaSyntax GetDocCommentNode(MemberDeclarationSyntax memberDeclaration)
{
var docCommentTrivia = memberDeclaration
.GetLeadingTrivia()
.Reverse()
.FirstOrDefault(t => t.IsDocComment());
if (!docCommentTrivia.IsDocComment())
{
return null;
}
return (DocumentationCommentTriviaSyntax)docCommentTrivia.GetStructure();
}
private static MemberDeclarationSyntax ChangeAccessibilityModifiersInDeclaration(MemberDeclarationSyntax declaration, SyntaxTokenList newAccessibilityModifiers)
{
var newDeclaration = declaration;
var actualTypeAccessibilityModifiers = GetAccessibilityModifiersFromMember(declaration);
var hasAccessibilityModifiers = actualTypeAccessibilityModifiers.Any();
var leadingTrivias = default(SyntaxTriviaList);
var trailingTrivias = default(SyntaxTriviaList);
if (!hasAccessibilityModifiers)
{
var modifiers = declaration.GetModifiers();
if (modifiers.Count > 0)
{
var firstModifier = modifiers.First();
leadingTrivias = firstModifier.LeadingTrivia;
newDeclaration = RemoveLeadingTriviasFromFirstDeclarationModifier(declaration, modifiers, firstModifier);
}
else
{
leadingTrivias = declaration.GetLeadingTrivia();
newDeclaration = RemoveLeadingTriviasFromDeclaration(declaration);
}
trailingTrivias = SyntaxFactory.TriviaList(SyntaxFactory.Space);
}
else
{
leadingTrivias = actualTypeAccessibilityModifiers.First().LeadingTrivia;
trailingTrivias = GetAllTriviasAfterFirstModifier(actualTypeAccessibilityModifiers);
}
newAccessibilityModifiers = MergeActualTriviasIntoNewAccessibilityModifiers(newAccessibilityModifiers, leadingTrivias, trailingTrivias);
newDeclaration = ReplaceDeclarationModifiers(newDeclaration, actualTypeAccessibilityModifiers.ToList(), newAccessibilityModifiers);
return newDeclaration;
}
private void MoveInitialTrivia(ref FieldDeclarationSyntax newField, ref MemberDeclarationSyntax newDeclaration)
{
var leadingTrivia = newDeclaration.GetLeadingTrivia();
if (!leadingTrivia.Any())
return;
var last = leadingTrivia.Last();
if (leadingTrivia.Any() && (SyntaxKind)last.RawKind == SyntaxKind.WhitespaceTrivia)
{
newField = newField.WithLeadingTrivia(leadingTrivia);
newDeclaration = newDeclaration.WithLeadingTrivia(last);
}
}
