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, getInnermostNodeForTie: true) as PrefixUnaryExpressionSyntax;

            if (syntaxNode == null)
            {
                return;
            }

            context.RegisterCodeFix(
                CodeAction.Create(
                    Title,
                    c =>
            {
                var expression = syntaxNode.Operand.RemoveParentheses();
                var newBinary  = ChangeOperator((BinaryExpressionSyntax)expression);

                if (syntaxNode.Parent is ExpressionSyntax &&
                    !ExpressionTypesWithNoParens.Any(type => type.IsInstanceOfType(syntaxNode.Parent)))
                {
                    newBinary = SyntaxFactory.ParenthesizedExpression(newBinary);
                }

                var newRoot = root.ReplaceNode(
                    syntaxNode,
                    newBinary.WithAdditionalAnnotations(Formatter.Annotation));

                return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
            }),
                context.Diagnostics);
        }
Beispiel #2
0
        public override sealed async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            var diagnostic     = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;
            var syntaxNode     = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as PrefixUnaryExpressionSyntax;

            if (syntaxNode == null)
            {
                return;
            }

            context.RegisterCodeFix(
                CodeAction.Create(
                    Title,
                    c =>
            {
                var expression    = syntaxNode.Operand;
                var parenthesized = expression as ParenthesizedExpressionSyntax;
                while (parenthesized != null)
                {
                    expression    = parenthesized.Expression;
                    parenthesized = expression as ParenthesizedExpressionSyntax;
                }

                var newBinary = ChangeOperator((BinaryExpressionSyntax)expression);

                if (syntaxNode.Parent is ExpressionSyntax &&
                    !ExpressionTypesWithNoParens.Any(type => type.IsInstanceOfType(syntaxNode.Parent)))
                {
                    newBinary = SyntaxFactory.ParenthesizedExpression(newBinary);
                }

                var newRoot = root.ReplaceNode(
                    syntaxNode,
                    newBinary.WithAdditionalAnnotations(Formatter.Annotation));

                return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
            }),
                context.Diagnostics);
        }