Can I get line characters from TextLine?

[MartyIX]

Hi,

I have a very simple analyzer¹ for checking if a source code line is too long (i.e. >183 characters).

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Text;

namespace Project.Analyzers.LongLines;

/// <summary>
/// Analyzer to check lines that are longer than <see cref="LineMaxLength"/>.
/// </summary>
/// <seealso href="https://stackoverflow.com/questions/71620389/whats-the-best-way-to-check-source-code-lines-for-exceeding-line-length-with-ro"/>
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class Ws0016 : DiagnosticAnalyzer
{
    /// <summary>Maximum limit of line length.</summary>
    public const int LineMaxLength = 183;

    /// <summary>List of sub-strings that justify long lines.</summary>
    private static readonly string[] Whitelist = 
    [
        // Logging commands.
        "log.Trace(",
        "log.Debug(",
        "log.Info(",
        "log.Warn(",
        "log.Error(",
        "log.Fatal(",

        // Moq.
        ".Setup(c =>",
    ];

    /// <inheritdoc/>
    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(AnalyzerDescriptors.LongLines);

    /// <inheritdoc/>
    public override void Initialize(AnalysisContext context)
    {
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();

        SyntaxKind[]? nodeTypes = Enum.GetValues(typeof(SyntaxKind)).Cast<SyntaxKind>().ToArray();
        context.RegisterSyntaxTreeAction(this.Analyze);
    }

    private void Analyze(SyntaxTreeAnalysisContext context)
    {
        Logger.Trace("*");

        try
        {
            SourceText text = context.Tree.GetText();
            IEnumerable<TextLine> longLines = text.Lines.Where(line => line.End - line.Start + 1 > LineMaxLength);

            foreach(TextLine line in longLines)
            {
                if (line.Text is not null) {
                    string lineString = line.Text.ToString(); // DO I NEED TO REALLY CALL `ToString`?

                    bool isOk = false;
                    foreach (string whiteListedString in Whitelist)
                    {
                        if (lineString.Contains(whiteListedString))
                        {
                            isOk = true;
                            break;
                        }
                    }

                    if (!isOk)
                    {
                        Location location = Location.Create(context.Tree, line.Span);
                        Diagnostic diagnostic = Diagnostic.Create(AnalyzerDescriptors.Ws0016LongLines, location, LineMaxLength);
                        context.ReportDiagnostic(diagnostic);
                    }
                }
            }
        }
        catch (Exception e)
        {
            Logger.Trace($"Analyzer exception thrown: {e}");
        }

        Logger.Trace("$<OK>");
    }
}

and now I wonder how to get string from TextLine. Currently, I call string lineString = line.Text.ToString(); but it's very suspicious to me. I don't believe it's correct performance-wise. How does one get string from TextLine correctly?

I don't strive for excellent performance but I would like to avoid unnecessary allocations if possible.

Footnotes

1. Original code is from StackOverflow. ↩

[CyrusNajmabadi]

You don't need to call ToString. You can get the characters just by indexing into the SourceText instance.

[MartyIX]

I can indeed index SourceText like this char lineChar = line.Text.text[1]; but then I would need to copy one character at a time to some buffer to get the actual line. Then once it's done I would need find out if the buffer contains a whitelisted string.

Is it really how one should work with it? It feels quite tedious.

[MartyIX]

Then there is SourceText.CopyTo and then I would have just one allocation but lines can be arbitrarily long, so that would require some clever handling as well

[CyrusNajmabadi]

SourceText is a string abstraction where the data need not be contiguous. But you are forcing contiguous storage by requiring processing to be done using System.Strings. I would advise not doing that. Just process the data in its native format, without copying.

[MartyIX]

Ok. So I do I understand correctly that reading by 1 character at time or by copying parts of the line to a buffer of mine is the solution that you propose (performance-wise)?

[CyrusNajmabadi]

Or use GetSubText and use SourceTexts as your unit of comparison.