A brief discussion about Linters and Formatters 🧹

LinterVsFormatter.md

Linter vs Formatter

Topics: #linter #formatter #csharpier #analyzer #ast

Note

I got inspired by these videos to write this document. 📼 They talk about linters and formatters in the context of JavaScript, but the concepts apply to C# as well.

• Theo - You're (probably) using Prettier Wrong (6 min video)
• Josh Goldberg - Setting Up ESLint and TypeScript for React (27 min video)

Important

• Formatters: CSharpier (C#) ~= Prettier (JS)
• Linters: SonarLint, or Reshaper (C#) ~= ESLint (JS)

⚠ !Don't use linters for formatting! ⚠

🧹 Formatter	💡Linter
✅ reformats in one pass	✅ Runs a set of discrete rules
⏩ Faster	🦥 Slower
❌ Can't find or fix bugs	❌ Explicit logic for edge cases

Formatters ( e.g. CSharpier)

A formatter is a tool that automatically adjusts the layout and style of code, ensuring it follows consistent formatting rules like indentation, spacing, and line breaks, without changing the code’s functionality. Its purpose is to make the code more readable and maintainable.

In C#, CSharpier is an opinionated code formatter for C# similar to Prettier in the JavaScript world. It focuses on styling your code according to a defined set of rules, ensuring consistency across your codebase.

Formatter usage example

Code before any tool is applied

int result= CalculateSum(5,10);
if(result>10){
Console.WriteLine("Result is greater than 10");
}else Console.WriteLine("Result is 10 or less");

The formatter will clean up the spacing, indentation, and general formatting rules:

int result = CalculateSum(5, 10);
if (result > 10)
{
    Console.WriteLine("Result is greater than 10");
}
else
{
    Console.WriteLine("Result is 10 or less");
}

• Added spaces around the assignment operator =, function parameters 5, 10, and comparison operator >.
• Formatted the else block into a multiline structure.
• Fixed indentation inside the if and else blocks for consistency.

Linter (e.g. SonarLint)

Note

Linters use static analysis Static Analysis: tooling that scrutinizes code without running it. (In contrast with "dynamic analysis": e.g. testing)

• A linter is a tool that runs a set of checks on your source code.
• Each of those checks are called a "rule".
• Each rule may report on code it doesn't like, and each complaint may contain an optional auto-fix and some reading material about it.

Tip

Each rule can be disabled locally or in the entire file, but also per assembly or even the entire project. Rules are not a silver bullet and it is common to have situations where we need to disable them. If that is your scenario, take a moment to understand the rule and do it judiciously and consider discussing it with your team.

Linters focuses more on finding and fixing potential issues in your code. Example of linters in C# are SonarLint or Resharper. They provide static analysis to help you identify code smells, errors, and potential bugs.

Tip

In C# we can create custom Analyzers. Read hear for an Overview of .NET source code analysis

Abstract Syntax Tree (AST)

Linters rely on Abstract Syntax Tree (AST) to work.

An Abstract Syntax Tree (AST) is a tree-like representation of the structure of source code. Each node in the tree represents a language construct, such as expressions, operators, or statements, without including details about the actual syntax (like parentheses or semicolons). It shows the logical structure of the code in a hierarchical manner.

Given this C# code example:

int sum = 2 + 3;

Here is the corresponding AST (simplified):

graph TD
    A[Assignment] --> B[Variable: sum]
    A --> C[Expression]
    C --> D[Left Operand: 2]
    C --> E[Operator: +]
    C --> F[Right Operand: 3]

Loading

(or a different way to represent that tree)

Assignment
├── Variable: sum
└── Expression
    ├── Left Operand: 2
    ├── Operator: +
    └── Right Operand: 3