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