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