private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, Diagnostic diagnostic) { var token = root.FindToken(diagnostic.Location.SourceSpan.Start, findInsideTrivia: true); var updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, token.WithLeadingTrivia(token.LeadingTrivia.Add(SyntaxFactory.Space)))); return Task.FromResult(updatedDocument); }
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken token) { SyntaxToken corrected = token.WithTrailingTrivia(token.TrailingTrivia.Insert(0, SyntaxFactory.Space)); Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected)); return Task.FromResult(updatedDocument); }
private Task<Document> AppendAsyncSuffixToMethodNameAsync(Document document, SyntaxNode root, SyntaxToken methodNameToken , CancellationToken cancellationToken) { string methodName = methodNameToken.Text; string newMethodName = (methodName.EndsWith("async") ? methodName.Substring(0, methodName.Length - 5) : methodName) + "Async"; SyntaxNode newRoot = root.ReplaceToken(methodNameToken, SyntaxFactory.Identifier(newMethodName)); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }
static Document PerformAction(Document document, SyntaxNode root, SyntaxToken token) { var node = token.Parent as LiteralExpressionSyntax; var newRoot = root.ReplaceToken( token, SyntaxFactory.ParseToken(string.Format("&H{0:x}", token.Value)) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()) ); return document.WithSyntaxRoot(newRoot); }
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken keywordToken) { SyntaxToken hashToken = keywordToken.GetPreviousToken(includeDirectives: true); if (!hashToken.IsKind(SyntaxKind.HashToken)) { return Task.FromResult(document); } SyntaxToken corrected = hashToken.WithoutTrailingWhitespace().WithoutFormatting(); Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(hashToken, corrected)); return Task.FromResult(updatedDocument); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var token = root.FindToken(diagnosticSpan.Start); context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.ReplaceToken(token, SyntaxFactory.Token(SyntaxKind.None)); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
public static async Task<Solution> RenameSymbolAsync(Document document, SyntaxNode root, SyntaxToken declarationToken, string newName, CancellationToken cancellationToken) { var annotatedRoot = root.ReplaceToken(declarationToken, declarationToken.WithAdditionalAnnotations(RenameAnnotation.Create())); var annotatedSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, annotatedRoot); var annotatedDocument = annotatedSolution.GetDocument(document.Id); annotatedRoot = await annotatedDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var annotatedToken = annotatedRoot.FindToken(declarationToken.SpanStart); var semanticModel = await annotatedDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var symbol = semanticModel.GetDeclaredSymbol(annotatedToken.Parent, cancellationToken); var newSolution = await Renamer.RenameSymbolAsync(annotatedSolution, symbol, newName, null, cancellationToken).ConfigureAwait(false); // TODO: return annotatedSolution instead of newSolution if newSolution contains any new errors (for any project) return newSolution; }
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, Diagnostic diagnostic) { var token = root.FindToken(diagnostic.Location.SourceSpan.Start, findInsideTrivia: true); SyntaxToken updatedToken; switch (token.Kind()) { case SyntaxKind.XmlTextLiteralToken: updatedToken = XmlSyntaxFactory.TextLiteral(" " + token.Text.TrimStart(' ')).WithTriviaFrom(token); break; default: updatedToken = token.WithLeadingTrivia(token.LeadingTrivia.Add(SyntaxFactory.Space)); break; } Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, updatedToken)); return Task.FromResult(updatedDocument); }
protected override SyntaxNode InsertAttributeListIntoContainer(int index, SyntaxNode list, SyntaxNode container) { // If the attribute list is being inserted at the first index and the container is not the compilation unit, copy leading trivia // to the list that is being inserted. if (index == 0 && !(container is CompilationUnitSyntax)) { var firstToken = container.GetFirstToken(); if (firstToken.HasLeadingTrivia) { var trivia = firstToken.LeadingTrivia; container = container.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(SyntaxTriviaList.Empty)); list = list.WithLeadingTrivia(trivia); } } if (container is CompilationUnitSyntax) { var compilationUnit = (CompilationUnitSyntax)container; var newAttributeLists = compilationUnit.AttributeLists.Insert(index, (AttributeListSyntax)list); return compilationUnit.WithAttributeLists(newAttributeLists); } else if (container is EnumDeclarationSyntax) { var enumDeclaration = (EnumDeclarationSyntax)container; var newAttributeLists = enumDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return enumDeclaration.WithAttributeLists(newAttributeLists); } else if (container is ClassDeclarationSyntax) { var classDeclaration = (ClassDeclarationSyntax)container; var newAttributeLists = classDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return classDeclaration.WithAttributeLists(newAttributeLists); } else if (container is StructDeclarationSyntax) { var structDeclaration = (StructDeclarationSyntax)container; var newAttributeLists = structDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return structDeclaration.WithAttributeLists(newAttributeLists); } else if (container is InterfaceDeclarationSyntax) { var interfaceDeclaration = (InterfaceDeclarationSyntax)container; var newAttributeLists = interfaceDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return interfaceDeclaration.WithAttributeLists(newAttributeLists); } else if (container is MethodDeclarationSyntax) { var method = (MethodDeclarationSyntax)container; var newAttributeLists = method.AttributeLists.Insert(index, (AttributeListSyntax)list); return method.WithAttributeLists(newAttributeLists); } else if (container is OperatorDeclarationSyntax) { var operationDeclaration = (OperatorDeclarationSyntax)container; var newAttributeLists = operationDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return operationDeclaration.WithAttributeLists(newAttributeLists); } else if (container is ConversionOperatorDeclarationSyntax) { var conversion = (ConversionOperatorDeclarationSyntax)container; var newAttributeLists = conversion.AttributeLists.Insert(index, (AttributeListSyntax)list); return conversion.WithAttributeLists(newAttributeLists); } else if (container is ConstructorDeclarationSyntax) { var constructor = (ConstructorDeclarationSyntax)container; var newAttributeLists = constructor.AttributeLists.Insert(index, (AttributeListSyntax)list); return constructor.WithAttributeLists(newAttributeLists); } else if (container is DestructorDeclarationSyntax) { var destructor = (DestructorDeclarationSyntax)container; var newAttributeLists = destructor.AttributeLists.Insert(index, (AttributeListSyntax)list); return destructor.WithAttributeLists(newAttributeLists); } else if (container is PropertyDeclarationSyntax) { var property = (PropertyDeclarationSyntax)container; var newAttributeLists = property.AttributeLists.Insert(index, (AttributeListSyntax)list); return property.WithAttributeLists(newAttributeLists); } else if (container is EventDeclarationSyntax) { var eventDeclaration = (EventDeclarationSyntax)container; var newAttributeLists = eventDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return eventDeclaration.WithAttributeLists(newAttributeLists); } else if (container is IndexerDeclarationSyntax) { var indexer = (IndexerDeclarationSyntax)container; var newAttributeLists = indexer.AttributeLists.Insert(index, (AttributeListSyntax)list); return indexer.WithAttributeLists(newAttributeLists); } else if (container is FieldDeclarationSyntax) { var field = (FieldDeclarationSyntax)container; var newAttributeLists = field.AttributeLists.Insert(index, (AttributeListSyntax)list); return field.WithAttributeLists(newAttributeLists); } else if (container is EventFieldDeclarationSyntax) { var eventFieldDeclaration = (EventFieldDeclarationSyntax)container; var newAttributeLists = eventFieldDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return eventFieldDeclaration.WithAttributeLists(newAttributeLists); } else if (container is DelegateDeclarationSyntax) { var delegateDeclaration = (DelegateDeclarationSyntax)container; var newAttributeLists = delegateDeclaration.AttributeLists.Insert(index, (AttributeListSyntax)list); return delegateDeclaration.WithAttributeLists(newAttributeLists); } else if (container is EnumMemberDeclarationSyntax) { var member = (EnumMemberDeclarationSyntax)container; var newAttributeLists = member.AttributeLists.Insert(index, (AttributeListSyntax)list); return member.WithAttributeLists(newAttributeLists); } else if (container is ParameterSyntax) { var parameter = (ParameterSyntax)container; var newAttributeLists = parameter.AttributeLists.Insert(index, (AttributeListSyntax)list); return parameter.WithAttributeLists(newAttributeLists); } else if (container is VariableDeclaratorSyntax || container is VariableDeclarationSyntax) { return InsertAttributeListIntoContainer(index, list, container.Parent); } throw Exceptions.ThrowEUnexpected(); }
private static SyntaxNode RemoveAnnotationIfExists(SyntaxNode root, SyntaxAnnotation annotation) { var element = root.GetAnnotatedNodesAndTokens(annotation).FirstOrDefault(); if (element == default(SyntaxNodeOrToken)) { return root; } if (element.IsNode) { var node = element.AsNode(); return root.ReplaceNode( node, node.WithoutAnnotations(annotation)); } var token = element.AsToken(); return root.ReplaceToken( token, token.WithoutAnnotations(annotation)); }
private static SyntaxNode MoveMember(SyntaxNode syntaxRoot, MemberDeclarationSyntax member, MemberDeclarationSyntax targetMember, IndentationOptions indentationOptions) { var firstToken = syntaxRoot.GetFirstToken(); var fileHeader = GetFileHeader(firstToken.LeadingTrivia); syntaxRoot = syntaxRoot.TrackNodes(member, targetMember, firstToken.Parent); var memberToMove = syntaxRoot.GetCurrentNode(member); var targetMemberTracked = syntaxRoot.GetCurrentNode(targetMember); if (!memberToMove.HasLeadingTrivia) { var targetIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, targetMember); var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, targetIndentationLevel); memberToMove = memberToMove.WithLeadingTrivia(SyntaxFactory.Whitespace(indentationString)); } if (!HasLeadingBlankLines(targetMember) && HasLeadingBlankLines(member)) { memberToMove = memberToMove.WithTrailingTrivia(memberToMove.GetTrailingTrivia().Add(SyntaxFactory.CarriageReturnLineFeed)); memberToMove = memberToMove.WithLeadingTrivia(GetLeadingTriviaWithoutLeadingBlankLines(memberToMove)); } syntaxRoot = syntaxRoot.InsertNodesBefore(targetMemberTracked, new[] { memberToMove }); var fieldToMoveTracked = syntaxRoot.GetCurrentNodes(member).Last(); syntaxRoot = syntaxRoot.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia); if (fileHeader.Any()) { var oldFirstToken = syntaxRoot.GetCurrentNode(firstToken.Parent).ChildTokens().First(); syntaxRoot = syntaxRoot.ReplaceToken(oldFirstToken, oldFirstToken.WithLeadingTrivia(StripFileHeader(oldFirstToken.LeadingTrivia))); var newFirstToken = syntaxRoot.GetFirstToken(); syntaxRoot = syntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(fileHeader.AddRange(newFirstToken.LeadingTrivia))); } return syntaxRoot; }
private static SyntaxNode ReAddFileHeader(SyntaxNode syntaxRoot, ImmutableArray<SyntaxTrivia> fileHeader) { if (fileHeader.IsEmpty) { // Only re-add the file header if it was stripped. return syntaxRoot; } var firstToken = syntaxRoot.GetFirstToken(includeZeroWidth: true); var newLeadingTrivia = firstToken.LeadingTrivia.InsertRange(0, fileHeader); return syntaxRoot.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(newLeadingTrivia)); }
private static SyntaxNode ReAddFileHeader(SyntaxNode syntaxRoot, SyntaxNode newSyntaxRoot) { var oldFirstToken = syntaxRoot.GetFirstToken(); if (!oldFirstToken.HasLeadingTrivia) { return newSyntaxRoot; } var fileHeader = UsingsHelper.GetFileHeader(oldFirstToken.LeadingTrivia.ToList()); if (!fileHeader.Any()) { return newSyntaxRoot; } var newFirstToken = newSyntaxRoot.GetFirstToken(); var newLeadingTrivia = newFirstToken.LeadingTrivia.InsertRange(0, fileHeader); return newSyntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(newLeadingTrivia)); }
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxToken token) { bool isAddingSpace = true; switch (token.Kind()) { case SyntaxKind.NewKeyword: { SyntaxToken nextToken = token.GetNextToken(); if (nextToken.IsKind(SyntaxKind.OpenBracketToken) || nextToken.IsKind(SyntaxKind.OpenParenToken)) { isAddingSpace = false; } } break; case SyntaxKind.ReturnKeyword: case SyntaxKind.ThrowKeyword: { SyntaxToken nextToken = token.GetNextToken(); if (nextToken.IsKind(SyntaxKind.SemicolonToken)) { isAddingSpace = false; } } break; case SyntaxKind.CheckedKeyword: case SyntaxKind.UncheckedKeyword: isAddingSpace = token.GetNextToken().IsKind(SyntaxKind.OpenBraceToken); break; case SyntaxKind.DefaultKeyword: case SyntaxKind.NameOfKeyword: case SyntaxKind.SizeOfKeyword: case SyntaxKind.TypeOfKeyword: isAddingSpace = false; break; case SyntaxKind.IdentifierToken: if (token.Text == "nameof") { // SA1000 would only have been reported for a nameof expression. No need to verify. goto case SyntaxKind.NameOfKeyword; } return Task.FromResult(document); default: break; } if (isAddingSpace == token.HasTrailingTrivia) { return Task.FromResult(document); } if (isAddingSpace) { SyntaxTrivia whitespace = SyntaxFactory.Space; SyntaxToken corrected = token.WithTrailingTrivia(token.TrailingTrivia.Insert(0, whitespace)); Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected)); return Task.FromResult(updatedDocument); } else { SyntaxToken corrected = token.WithoutTrailingWhitespace().WithoutFormatting(); Document updatedDocument = document.WithSyntaxRoot(root.ReplaceToken(token, corrected)); return Task.FromResult(updatedDocument); } }