static SyntaxNode GetNewRoot(SyntaxNode root, SyntaxNode node) { var decl = node.AncestorsAndSelf().OfType<LocalDeclarationStatementSyntax>().FirstOrDefault(); if (decl != null) return root.RemoveNode(decl, SyntaxRemoveOptions.KeepNoTrivia); if (node.Parent.IsKind(SyntaxKind.ElseClause)) return root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia); var statement = node as StatementSyntax; if (statement != null) return root.RemoveNode(statement, SyntaxRemoveOptions.KeepNoTrivia); return root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia); }
private static SyntaxNode CalculateNewRoot(SyntaxNode root, IfStatementSyntax ifStatement) { SyntaxNode newRoot; var isTrue = ifStatement.Condition.IsKind(SyntaxKind.TrueLiteralExpression); if (isTrue) { var block = ifStatement.Statement as BlockSyntax; newRoot = block == null ? root.ReplaceNode(ifStatement, ifStatement.Statement) : root.ReplaceNode(ifStatement, block.Statements); } else { if (ifStatement.Else == null) { newRoot = root.RemoveNode(ifStatement, SyntaxRemoveOptions.KeepNoTrivia); } else { var block = ifStatement.Else.Statement as BlockSyntax; newRoot = block == null ? root.ReplaceNode(ifStatement, ifStatement.Else.Statement) : root.ReplaceNode(ifStatement, block.Statements); } } return newRoot.WithAdditionalAnnotations(Formatter.Annotation); }
public async static Task<Solution> MakeAutoPropertyAsync(Document document, SyntaxNode root, PropertyDeclarationSyntax property, CancellationToken cancellationToken) { var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var getterReturn = (ReturnStatementSyntax)property.AccessorList.Accessors.First(a => a.Keyword.ValueText == "get").Body.Statements.First(); var returnIdentifier = (IdentifierNameSyntax)(getterReturn.Expression is MemberAccessExpressionSyntax ? ((MemberAccessExpressionSyntax)getterReturn.Expression).Name : getterReturn.Expression); var returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol; var variableDeclarator = (VariableDeclaratorSyntax)returnIdentifierSymbol.DeclaringSyntaxReferences.First().GetSyntax(); var fieldDeclaration = variableDeclarator.FirstAncestorOfType<FieldDeclarationSyntax>(); root = root.TrackNodes(returnIdentifier, fieldDeclaration, property); document = document.WithSyntaxRoot(root); root = await document.GetSyntaxRootAsync(cancellationToken); semanticModel = await document.GetSemanticModelAsync(cancellationToken); returnIdentifier = root.GetCurrentNode(returnIdentifier); returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol; var newProperty = GetSimpleProperty(property, variableDeclarator) .WithTriviaFrom(property) .WithAdditionalAnnotations(Formatter.Annotation); var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, returnIdentifierSymbol, property.Identifier.ValueText, document.Project.Solution.Workspace.Options, cancellationToken); document = newSolution.GetDocument(document.Id); root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); root = root.InsertNodesAfter(root.GetCurrentNode(property), new[] { newProperty }); var multipleVariableDeclaration = fieldDeclaration.Declaration.Variables.Count > 1; if (multipleVariableDeclaration) { var newfieldDeclaration = fieldDeclaration.WithDeclaration(fieldDeclaration.Declaration.RemoveNode(variableDeclarator, SyntaxRemoveOptions.KeepNoTrivia)); root = root.RemoveNode(root.GetCurrentNode<SyntaxNode>(property), SyntaxRemoveOptions.KeepNoTrivia); root = root.ReplaceNode(root.GetCurrentNode(fieldDeclaration), newfieldDeclaration); } else { root = root.RemoveNodes(root.GetCurrentNodes<SyntaxNode>(new SyntaxNode[] { fieldDeclaration, property }), SyntaxRemoveOptions.KeepNoTrivia); } document = document.WithSyntaxRoot(root); return document.Project.Solution; }
private static SyntaxNode CalculateNewRoot(SyntaxNode root, SyntaxNode currentNode, TryStatementSyntax tryStatement) { var isTryRemovable = tryStatement.Catches.Count == 1 && tryStatement.Finally == null; return isTryRemovable ? root.ReplaceNode( tryStatement, tryStatement.Block.Statements.Select(st => st.WithAdditionalAnnotations(Formatter.Annotation))) : root.RemoveNode(currentNode, SyntaxRemoveOptions.KeepNoTrivia); }
private static void RegisterActionForDestructor(CodeFixContext context, SyntaxNode root, BaseMethodDeclarationSyntax method) { context.RegisterCodeFix( CodeAction.Create( TitleRemoveDestructor, c => { var newRoot = root.RemoveNode( method, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }, TitleRemoveDestructor), context.Diagnostics); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var syntaxNode = root.FindNode(diagnosticSpan); context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(syntaxNode, SyntaxRemoveOptions.KeepExteriorTrivia | SyntaxRemoveOptions.KeepEndOfLine); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
private static Solution GetDocumentWithClassDeclarationRemoved(Project project, Document document, SyntaxNode syntaxTree, TypeDeclarationSyntax declaration, IEnumerable<SyntaxNode> otherTypeDeclarationsInFile) { if (otherTypeDeclarationsInFile.Any() || !RoslynBug857331Fixed) { var newSyntaxTree = syntaxTree.RemoveNode(declaration, SyntaxRemoveOptions.KeepNoTrivia); return document.WithSyntaxRoot(newSyntaxTree).Project.Solution; } else { var emptyDocumentId = document.Id; if (project.Solution.GetDocument(emptyDocumentId) != null) { var projectWithFileRemoved = project.Solution.RemoveDocument(emptyDocumentId); return projectWithFileRemoved; } return project.Solution; } }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var syntaxNode = root.FindNode(diagnosticSpan); if (syntaxNode.Parent is ExpressionStatementSyntax) { context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(syntaxNode.Parent, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); } }
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxNode node) { // The first token is the open parenthesis token. This token has all the inner trivia var firstToken = node.GetFirstToken(); var lastToken = node.GetLastToken(); var previousToken = firstToken.GetPreviousToken(); // We want to keep all trivia. The easiest way to do that is by doing it manually var newSyntaxRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia); // The removing operation has not changed the location of the previous token var newPreviousToken = newSyntaxRoot.FindToken(previousToken.Span.Start); var newTrailingTrivia = newPreviousToken.TrailingTrivia.AddRange(firstToken.GetAllTrivia()).AddRange(lastToken.GetAllTrivia()); newSyntaxRoot = newSyntaxRoot.ReplaceToken(newPreviousToken, newPreviousToken.WithTrailingTrivia(newTrailingTrivia)); return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot)); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var syntaxNode = root.FindNode(diagnosticSpan) as NamespaceDeclarationSyntax; if (syntaxNode == null) { return; } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(syntaxNode, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
private static SyntaxNode CalculateNewRoot(SyntaxNode root, Diagnostic diagnostic, StatementSyntax currentAsStatement, AssignmentExpressionSyntax currentAsAssignment, BinaryExpressionSyntax currentAsBinary) { if (currentAsStatement != null) { return root.RemoveNode(currentAsStatement, SyntaxRemoveOptions.KeepNoTrivia); } if (currentAsAssignment != null) { return root.ReplaceNode( currentAsAssignment, currentAsAssignment.Left.WithAdditionalAnnotations(Formatter.Annotation)); } var isReportingOnLeft = bool.Parse(diagnostic.Properties[SillyBitwiseOperation.IsReportingOnLeftKey]); return root.ReplaceNode( currentAsBinary, (isReportingOnLeft ? currentAsBinary.Right : currentAsBinary.Left).WithAdditionalAnnotations(Formatter.Annotation)); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var nodeToRemove = root.FindNode(diagnosticSpan); var attributeList = nodeToRemove.Parent as AttributeListSyntax; if (attributeList != null && attributeList.Attributes.Count == 1) { nodeToRemove = attributeList; } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(nodeToRemove, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var parameter = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as ParameterSyntax; if (!bool.Parse(diagnostic.Properties[MethodParameterUnused.IsRemovableKey])) { return; } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode( parameter, SyntaxRemoveOptions.KeepLeadingTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
public static SyntaxNode RemoveUnreachableStatement(SyntaxNode root, SyntaxNode node) { if (node.Parent.IsKind(SyntaxKind.IfStatement, SyntaxKind.WhileStatement)) return root.ReplaceNode(node, SyntaxFactory.Block()); if (node.Parent.IsKind(SyntaxKind.ElseClause)) return root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia); var statement = node as StatementSyntax;//for, while, foreach, if, throw, var, etc if (statement != null) return root.RemoveNode(statement, SyntaxRemoveOptions.KeepNoTrivia); var localDeclaration = node.FirstAncestorOfType<LocalDeclarationStatementSyntax>(); if (localDeclaration != null) return root.RemoveNode(localDeclaration, SyntaxRemoveOptions.KeepNoTrivia); var expression = GetExpression(node); if (expression.Parent.IsKind(SyntaxKind.ForStatement)) return root.RemoveNode(expression, SyntaxRemoveOptions.KeepNoTrivia); var expressionStatement = expression.FirstAncestorOfType<ExpressionStatementSyntax>(); if (expressionStatement.Parent.IsKind(SyntaxKind.IfStatement, SyntaxKind.WhileStatement)) return root.ReplaceNode(expressionStatement, SyntaxFactory.Block()); if (expressionStatement.Parent.IsKind(SyntaxKind.ElseClause)) return root.RemoveNode(expressionStatement.Parent, SyntaxRemoveOptions.KeepNoTrivia); return root.RemoveNode(expressionStatement, SyntaxRemoveOptions.KeepNoTrivia); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var memberAccess = (MemberAccessExpressionSyntax)root.FindNode(diagnosticSpan); var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var fieldSymbol = (IFieldSymbol)semanticModel.GetSymbolInfo(memberAccess.Expression).Symbol; var typeParameterSymbol = (ITypeParameterSymbol)fieldSymbol.Type; var genericType = typeParameterSymbol.ContainingType; var classDeclarationTasks = genericType.DeclaringSyntaxReferences .Select(reference => reference.GetSyntaxAsync(context.CancellationToken)) .ToList(); await Task.WhenAll(classDeclarationTasks); var classDeclarations = classDeclarationTasks .Select(task => task.Result as ClassDeclarationSyntax) .Where(cl => cl != null) .ToList(); if (classDeclarations.Any()) { context.RegisterCodeFix( CodeAction.Create( TitleAddClassConstraint, async c => { var currentSolution = context.Document.Project.Solution; var mapping = GetDocumentIdClassDeclarationMapping(classDeclarations, currentSolution); foreach (var classes in mapping) { var document = currentSolution.GetDocument(classes.Key); var docRoot = await document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var newDocRoot = GetNewDocumentRoot(docRoot, typeParameterSymbol, classes); currentSolution = currentSolution.WithDocumentSyntaxRoot(classes.Key, newDocRoot); } return currentSolution; }), context.Diagnostics); } var expression = memberAccess.Parent as ExpressionSyntax; var statement = expression?.Parent as StatementSyntax; if (statement == null) { return; } context.RegisterCodeFix( CodeAction.Create( TitleRemove, c => { var newRoot = root.RemoveNode(statement, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }), context.Diagnostics); }
internal static SyntaxNode RemoveUnusedCode(SyntaxNode root, SyntaxNode syntaxNode) { return root.RemoveNode(syntaxNode.Parent, SyntaxRemoveOptions.KeepNoTrivia); }
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 Document PerformAction(Document document, SemanticModel model, SyntaxNode root, String name, PropertyDeclarationSyntax newProperty, SyntaxAnnotation propAnno, SyntaxAnnotation fieldAnno) { var oldField = root.GetAnnotatedNodes(fieldAnno).First() as FieldDeclarationSyntax; if (oldField.Declaration.Variables.Count == 1) { var newRoot = root.RemoveNode(oldField, SyntaxRemoveOptions.KeepNoTrivia); var oldProperty = newRoot.GetAnnotatedNodes(propAnno).First(); newRoot = newRoot.ReplaceNode((SyntaxNode)oldProperty, newProperty); return document.WithSyntaxRoot(newRoot); } else { FieldDeclarationSyntax newField = oldField.WithDeclaration(SyntaxFactory.VariableDeclaration(oldField.Declaration.Type)); //need to replace the field with one missing the variable field foreach (var variable in oldField.Declaration.Variables) { if (!variable.Identifier.ValueText.Equals(name)) newField = newField.AddDeclarationVariables(variable); } var newRoot = root.ReplaceNode((SyntaxNode)oldField, newField.WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(oldField.GetLeadingTrivia())); var oldProperty = newRoot.GetAnnotatedNodes(propAnno).First(); newRoot = newRoot.ReplaceNode((SyntaxNode)oldProperty, newProperty.WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(oldProperty.GetLeadingTrivia())); return document.WithSyntaxRoot(newRoot); } }
internal static SyntaxNode RemoveUnusedCode(SyntaxNode root, SyntaxNode syntaxNode) { return root.RemoveNode(syntaxNode, SyntaxRemoveOptions.KeepNoTrivia | SyntaxRemoveOptions.KeepEndOfLine); }
private static CodeAction CreateActionWithRemovedCatchClause(CodeFixContext context, SyntaxNode root, SyntaxNode syntaxNode) { return CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(syntaxNode, SyntaxRemoveOptions.KeepNoTrivia); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }); }
private static SyntaxNode RemoveField(SyntaxNode root, VariableDeclaratorSyntax variableDeclarator, FieldDeclarationSyntax fieldDeclaration) { var currentField = root.GetCurrentNode(fieldDeclaration); var multipleVariableDeclaration = fieldDeclaration.Declaration.Variables.Count > 1; root = multipleVariableDeclaration ? root.ReplaceNode(currentField, fieldDeclaration .WithDeclaration(fieldDeclaration.Declaration.RemoveNode(variableDeclarator, SyntaxRemoveOptions.KeepNoTrivia))) : root.RemoveNode(currentField, SyntaxRemoveOptions.KeepNoTrivia); return root; }
private static SyntaxNode MoveField(SyntaxNode root, MemberDeclarationSyntax field, MemberDeclarationSyntax firstNonConst) { var trackedRoot = root.TrackNodes(field, firstNonConst); var fieldToMove = trackedRoot.GetCurrentNode(field); var firstNonConstTracked = trackedRoot.GetCurrentNode(firstNonConst); if (!fieldToMove.HasLeadingTrivia) { fieldToMove = fieldToMove.WithLeadingTrivia(firstNonConstTracked.GetLeadingTrivia().Where(x => x.IsKind(SyntaxKind.WhitespaceTrivia)).LastOrDefault()); } root = trackedRoot.InsertNodesBefore(firstNonConstTracked, new[] { fieldToMove }); var fieldToMoveTracked = root.GetCurrentNodes(field).Last(); return root.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia); }