C# SyntaxNode.RemoveNode方法代码示例

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