private static bool Remove(Label label, ref SyntaxNode tree)
{
var members = tree.GetMembers()
.Where(node => node.Identifier().ValueText == label.Name)
.ToList();
if (!members.Any())
return false;
if (label.OnlyBody)
tree = tree.RemoveNodes(members.SelectMany(syntax => syntax.GetBody()), SyntaxRemoveOptions.KeepNoTrivia);
else
tree = tree.RemoveNodes(members, SyntaxRemoveOptions.KeepExteriorTrivia);
return true;
}
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 async Task<Solution> CreateFiles(Document document, SyntaxNode root,
SemanticModel model, ImmutableArray<TypeToRemove> typesToRemove,
Func<string, string> typeFolderGenerator,
CancellationToken token)
{
var project = document.Project;
var workspace = project.Solution.Workspace;
project = ExtractTypesToFilesCodeRefactoringProvider.MoveTypeNodes(
model, typesToRemove, typeFolderGenerator, project, token);
var newRoot = root.RemoveNodes(
typesToRemove.Select(_ => _.Declaration),
SyntaxRemoveOptions.AddElasticMarker);
var newSolution = project.Solution;
var projectId = project.Id;
newSolution = newSolution.WithDocumentSyntaxRoot(document.Id, newRoot);
var newDocument = newSolution.GetProject(project.Id).GetDocument(document.Id);
newRoot = await newDocument.GetSyntaxRootAsync(token);
var newModel = await newDocument.GetSemanticModelAsync(token);
var newUsings = newRoot.GenerateUsingDirectives(newModel);
newRoot = newRoot.RemoveNodes(
newRoot.DescendantNodes(_ => true).OfType<UsingDirectiveSyntax>(),
SyntaxRemoveOptions.AddElasticMarker);
newRoot = (newRoot as CompilationUnitSyntax)?.WithUsings(newUsings);
return newSolution.WithDocumentSyntaxRoot(document.Id, newRoot);
}
public async Task<SyntaxNode> ProcessAsync(Document document, SyntaxNode syntaxNode, CancellationToken cancellationToken)
{
var model = await document.GetSemanticModelAsync(cancellationToken);
var diagnostics = model.GetDiagnostics().Where(s => s.Id == "CS8019");
var usingDirectives = new List<SyntaxNode>();
var newDocument = document;
foreach (var diagnostic in diagnostics)
{
var text = diagnostic.Location.SourceSpan;
var token = syntaxNode.FindToken(text.Start); // do I need to get the root from the document?
usingDirectives.Add(token.Parent);
}
var newNode = syntaxNode.RemoveNodes(usingDirectives, SyntaxRemoveOptions.KeepNoTrivia);
if (newNode != syntaxNode)
{
newDocument = document.WithSyntaxRoot(newNode);
}
return await newDocument.GetSyntaxRootAsync(cancellationToken);
}
private static SyntaxNode GetNewDocumentSyntaxTree(SyntaxNode syntaxTree, List<SyntaxNode> otherTypeDeclarationsInFile)
{
return syntaxTree.RemoveNodes(otherTypeDeclarationsInFile, SyntaxRemoveOptions.KeepNoTrivia);
}
private static SyntaxNode RemoveUnusedImportDirectives(SemanticModel semanticModel, SyntaxNode root, CancellationToken cancellationToken)
{
var oldUsings = root.DescendantNodesAndSelf().Where(s => s is UsingDirectiveSyntax);
var unusedUsings = GetUnusedImportDirectives(semanticModel, cancellationToken);
SyntaxTriviaList leadingTrivia = root.GetLeadingTrivia();
root = root.RemoveNodes(oldUsings, SyntaxRemoveOptions.KeepNoTrivia);
var newUsings = SyntaxFactory.List(oldUsings.Except(unusedUsings));
root = ((CompilationUnitSyntax)root)
.WithUsings(newUsings)
.NormalizeWhitespace()
.WithLeadingTrivia(leadingTrivia);
return root;
}
private Task<Document> RemoveUsingStatement(Document document, SyntaxNode root, IEnumerable<SyntaxNode> usingDirectiveNodes)
{
return Task.FromResult(
document.WithSyntaxRoot(root.RemoveNodes(usingDirectiveNodes, SyntaxRemoveOptions.KeepLeadingTrivia)));
}
