CSharpierIgnore.cs

using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using CSharpier.Core.DocTypes;
using CSharpier.Core.Utilities;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace CSharpier.Core.CSharp.SyntaxPrinter;

internal static partial class CSharpierIgnore
{
#if NET8_0_OR_GREATER
    [GeneratedRegex("^// csharpier-ignore($| -)")]
    private static partial Regex IgnoreRegexGenerator();

    [GeneratedRegex("^// csharpier-ignore-start($| -)")]
    private static partial Regex IgnoreStartRegexGenerator();

    [GeneratedRegex("^// csharpier-ignore-end($| -)")]
    private static partial Regex IgnoreEndRegexGenerator();

    [GeneratedRegex(@"[\t\v\f ]*(\r\n?|\n)")]
    private static partial Regex WhiteSpaceLineEndingsGenerator();

    private static readonly Regex IgnoreRegex = IgnoreRegexGenerator();
    public static readonly Regex IgnoreStartRegex = IgnoreStartRegexGenerator();
    public static readonly Regex IgnoreEndRegex = IgnoreEndRegexGenerator();
    public static readonly Regex WhiteSpaceLineEndingsRegex = WhiteSpaceLineEndingsGenerator();
#else
    private static readonly Regex IgnoreRegex = new(
        "^// csharpier-ignore($| -)",
        RegexOptions.Compiled
    );
    public static readonly Regex IgnoreStartRegex = new(
        "^// csharpier-ignore-start($| -)",
        RegexOptions.Compiled
    );
    public static readonly Regex IgnoreEndRegex = new(
        "^// csharpier-ignore-end($| -)",
        RegexOptions.Compiled
    );
    public static readonly Regex WhiteSpaceLineEndingsRegex = new(
        @"[\t\v\f ]*(\r\n?|\n)",
        RegexOptions.Compiled
    );
#endif

    public static bool HasIgnoreComment(SyntaxNode syntaxNode)
    {
        return Token.HasLeadingCommentMatching(syntaxNode, IgnoreRegex);
    }

    public static bool HasIgnoreComment(SyntaxToken syntaxToken)
    {
        return Token.HasLeadingCommentMatching(syntaxToken, IgnoreRegex);
    }

    public static bool IsNodeIgnored(SyntaxNode syntaxNode)
    {
        // this get handled in BaseMethodDeclaration and/or AttributeList
        if (
            syntaxNode is BaseMethodDeclarationSyntax baseMethodDeclarationSyntax
            && baseMethodDeclarationSyntax.AttributeLists.Any()
        )
        {
            return false;
        }

        return syntaxNode.Parent?.Kind()
                is SyntaxKind.ClassDeclaration
                    or SyntaxKind.StructDeclaration
                    or SyntaxKind.InterfaceDeclaration
                    or SyntaxKind.RecordDeclaration
                    or SyntaxKind.RecordStructDeclaration
                    or SyntaxKind.EnumDeclaration
                    or SyntaxKind.Block
                    or SyntaxKind.CompilationUnit
                    or SyntaxKind.NamespaceDeclaration
                    or SyntaxKind.SwitchSection
            && HasIgnoreComment(syntaxNode);
    }

    [SkipLocalsInit]
    public static List<Doc> PrintNodesRespectingRangeIgnore<T>(
        SyntaxList<T> list,
        CSharpPrintingContext context
    )
        where T : SyntaxNode
    {
        var statements = new List<Doc>();
        var unFormattedCode = new StringBuilder();
        var printUnformatted = false;
        SyntaxNode? firstUnformattedNode = null;

        foreach (var node in list)
        {
            if (Token.HasLeadingCommentMatching(node, IgnoreEndRegex))
            {
                statements.Add(
                    firstUnformattedNode is StatementSyntax statementSyntax
                        ? Doc.Concat(
                            ExtraNewLines.Print(statementSyntax),
                            unFormattedCode.ToString().Trim()
                        )
                        : unFormattedCode.ToString().Trim()
                );
                unFormattedCode.Clear();
                firstUnformattedNode = null;
                printUnformatted = false;
            }
            else if (Token.HasLeadingCommentMatching(node, IgnoreStartRegex))
            {
                firstUnformattedNode ??= node;
                printUnformatted = true;
            }

            if (printUnformatted)
            {
                unFormattedCode.Append(PrintWithoutFormatting(node, context));
            }
            else
            {
                statements.Add(Node.Print(node, context));
            }
        }

        if (unFormattedCode.Length > 0)
        {
            statements.Add(
                firstUnformattedNode is StatementSyntax statementSyntax
                    ? Doc.Concat(
                        ExtraNewLines.Print(statementSyntax),
                        unFormattedCode.ToString().Trim()
                    )
                    : unFormattedCode.ToString().Trim()
            );
        }

        return statements;
    }

    public static string PrintWithoutFormatting(
        SyntaxNode syntaxNode,
        CSharpPrintingContext context
    )
    {
        return PrintWithoutFormatting(syntaxNode.GetText().ToString(), context);
    }

    public static string PrintWithoutFormatting(string code, CSharpPrintingContext context)
    {
        // trim trailing whitespace + replace only existing line endings
        return WhiteSpaceLineEndingsRegex.Replace(code, context.LineEnding);
    }
}