Home > Articles > Programming > C#

  • Print
  • + Share This
From the author of Finding Nodes

Finding Nodes

Let's start writing the code to find the appropriate if nodes and make necessary modifications. The first step is to replace the template TestMethod2 with a test where the input program contains the first case in the sample code shown earlier. When we've updated the analyzer and the code fix, braces should be added to the predicate for the if clause. The basic test now looks like this (see branch 03-UpdateBasicTest):

        //Diagnostic and CodeFix both triggered and checked for
        [TestMethod]
        public void IfStatementWithoutBraces()
        {
            var test = @"
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SampleCode
{
    class Program
    {
        static void Main(string[] args)
        {
            bool b1 = true;

            if (b1)
                Console.WriteLine(""b1"");

        }
    }
}";
            var expected = new DiagnosticResult
            {
                Id = IfClauseDiagnosticAnalyzer.DiagnosticId,
                Message = "if clauses should be surrounded by braces.",
                Severity = DiagnosticSeverity.Info,
                Locations =
                    new[] {
                            new DiagnosticResultLocation("Test0.cs", 11, 15)
                        }
            };

            VerifyCSharpDiagnostic(test, expected);

            var fixtest = @"
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SampleCode
{
    class Program
    {
        static void Main(string[] args)
        {
            bool b1 = true;

            if (b1)
            {
                Console.WriteLine(""b1"");
            }
        }
    }
}";
            VerifyCSharpFix(test, fixtest);
        }

We haven't written the code in the analyzer yet, so this test fails. The first change we need to make is to register the proper action type: We analyze if blocks on a SyntaxNode action where the SyntaxKind is an if statement:

public override void Initialize(AnalysisContext context)
{
    context.RegisterSyntaxNodeAction(AnalyzeIfBlock, SyntaxKind.IfStatement);
}

Next, we need to analyze the if block and determine whether the then clause is an ExpressionStatement or a Block. This is easiest to do by looking at the Syntax Analyzer as you write the code. You don't need to write much code to determine whether this rule is broken. The AnalyzeIfBlock method takes a SyntaxNodeAnalysisContext as its argument. The Node property represents the code being analyzed. In our case, that Node must be an IfStatementSyntax node. The IfStatementSyntax node contains a Statement property that represents the code executed when the if (clause) is true. You simply look at that Statement property and see whether its type is an ExpressionStatementSyntax or a Block. If it is an ExpressionStatementSyntax, then you need to raise the diagnostic:

private static void AnalyzeIfBlock(SyntaxNodeAnalysisContext context)
{
    var statement = context.Node as IfStatementSyntax;

    var thenClause = statement.Statement;

    if (thenClause is ExpressionStatementSyntax)
    {
        // create the diagnostic:
        var diagnostic = Diagnostic.Create(Rule, statement.GetLocation(), "true clause");
        context.ReportDiagnostic(diagnostic);
    }
}

At this point, you can run the tests again (check out branch 04-DiagnosticFindsIfBlocks). The test still fails, but our diagnostic finds the if block and reports the problem. Now, we need to write the code fix to replace the ExpressionStatement with a Block. We need to replace the template code with code that registers a fix to replace the ExpressionStatement with a Block that contains the ExpressionStatement. The first step is to update ComputeFixesAsync to register the fix for the Statement node on the IfStatement. This is done by overriding the ComputeFixesAsync method in the CodeFix class:

public sealed override async Task ComputeFixesAsync(CodeFixContext context)
{
    var root = await context.Document
        .GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

    var diagnostic = context.Diagnostics.First();
    var diagnosticSpan = diagnostic.Location.SourceSpan;

    // Find the type declaration identified by the diagnostic.
    var statement = root.FindToken(diagnosticSpan.Start)
        .Parent.AncestorsAndSelf().OfType<ExpressionStatementSyntax>().First();

    // Register a code action that will invoke the fix.
    context.RegisterFix(
        CodeAction.Create("Make Block",
        c => MakeBlockAsync(context.Document, statement, c)),
        diagnostic);
}

Now comes the really fun part: We have to write the code fix so that it replaces the ExpressionStatement with a Block containing that ExpressionStatement. Yes, we'll be programmatically modifying the program.

As we write the code fix, it's important to remember that syntax trees are immutable. That means we have to return a copy of the objects we change, rather than just manipulating the objects we need to change. Our code fix needs to make a new Document object that has replaced the ExpressionStatement with the correct Block object. The entire method is here (check out branch 05-CodeFixBasicsWork):

private async Task<Document> MakeBlockAsync(Document document,
    ExpressionStatementSyntax trueStatement, CancellationToken cancellationToken)
{
    var block = SyntaxFactory.Block(trueStatement);

    var root = await document.GetSyntaxRootAsync();

    var newRoot = root.ReplaceNode((SyntaxNode)trueStatement, block);

    var newDocument = document.WithSyntaxRoot(newRoot);
    return newDocument;
}

This is all new code, so let's go through each line carefully. The first line creates a new Block syntax element whose contents is the single ExpressionSyntaxStatement represented by trueStatement. The next two lines create a new syntax tree where the existing expression syntax statement has been replaced by the Block. Finally, a new document is created with the new syntax root.

Run the tests, and you'll find this code still fails. However, it's very close. The resulting program text looks like this:

            if (b1)
{                Console.WriteLine(""b1"");
}

It's semantically correct, but it doesn't represent the source formatting. We haven't handled any of the WhitespaceTrivia or EndOfLineTrivia correctly. Getting the whitespace right is one of the trickiest parts of any code-fix analyzer. Let's go through the updated method line by line and explain how the changes handle the whitespace (check out branch 06-HandlingTrivia):

private async Task<Document> MakeBlockAsync(Document document, ExpressionStatementSyntax trueStatement,
    CancellationToken cancellationToken)
{
    // Create the important trivia that we need.
    var statementLeadingTrivia = trueStatement.GetLeadingTrivia();
    var statementLeadingWhiteSpace = trueStatement.Parent.GetLeadingTrivia()
        .Where(t => t.CSharpKind() == SyntaxKind.WhitespaceTrivia).Single();
    var endOfLineTrivia = SyntaxFactory.EndOfLine("\r\n");
    var blockLeadingTrivia = statementLeadingTrivia.Insert(0, endOfLineTrivia);

    // Create the statements that go in the block:
    var statements = new SyntaxList<StatementSyntax>();
    statements = statements.Add(trueStatement.WithLeadingTrivia(blockLeadingTrivia));

    // Create the brace tokens (with whitespace trivia) and the then block:
    var openingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.OpenBraceToken)
        .WithLeadingTrivia(statementLeadingWhiteSpace);
    var closingTokenWithTrivia = SyntaxFactory.Token(SyntaxKind.CloseBraceToken)
        .WithLeadingTrivia(statementLeadingWhiteSpace);

    var block = SyntaxFactory.Block(openingTokenWithTrivia, statements,
        closingTokenWithTrivia);

    // Replace the old statement with the block:
    var root = await document.GetSyntaxRootAsync();
    var newRoot = root.ReplaceNode((SyntaxNode)trueStatement, block);

    var newDocument = document.WithSyntaxRoot(newRoot);
    return newDocument;
}

The first five lines create or capture the trivia we'll need to format the block correctly. First, we get all the leading trivia for the true statement. This is the list of all leading trivia. It would be the EndofLine trivia and the Whitespace trivia. The next line retrieves the WhitespaceTrivia node from the list of trivia. Next, it's time to create a new EndOfLine trivia object. Finally, we create a new TriviaList that contains an EndOfLine trivia, followed by the whitespace needed to indent the statement correctly inside the block.

The next two lines create a SyntaxList that contains the single expression statement. Even though the block we create contains a single statement, we need a SyntaxList object to match the overload to create the block with the properly indented braces.

Next, we create the opening and closing brace tokens with the appropriate leading trivia (whitespace and end-of-line). Once the brace tokens with indenting are created, the next line creates the block and uses the formatted brace tokens.

The remaining code is the same as before: It replaces the statement node and returns the new document. After these changes, you can run your tests and see that everything passes.

  • + Share This
  • 🔖 Save To Your Account