Início / coding / Perguntas / 79254211
Accepted
Andrew Malachov
Asked: 2024-12-05 18:12:13 +0800 CST

Posso suprimir erros do compilador personalizado com o Roslyn?

  • 772

Eu trabalho com uma plataforma que usa intensamente reflexão e geração de código para inicializar membros de certos tipos especiais. Parece algo assim:

public class MyGraph : PXGraph<MyGraph>
{
    public PXSelect<DBTable> view;
}

Quero adicionar análise de tipos de referência anuláveis ​​ao meu código. No entanto, não consigo encontrar uma solução elegante que evite vários avisos sobre campos não anuláveis ​​não inicializados. Eles são exibidos em campos ou no construtor de tipo. A plataforma os inicializa

Eu sei que posso suprimir avisos da análise anulável. No entanto, não gosto da aparência. Não gosto de pragmas porque eles desorganizam o código, e não gosto ainda mais de atributos de supressão.

Não gosto da seguinte declaração porque me parece um absurdo:

public class MyGraph : PXGraph<MyGraph>
{
    public PXSelect<DBTable> view = null!; // or = default!
}

Também tentei atributos anuláveis ​​sem muito benefício.

Tentei usar a requiredpalavra-chave assim:

public class MyGraph : PXGraph<MyGraph>
{
    public required PXSelect<DBTable> view;
}

Gosto mais dessa declaração, mas recebo erro do compilador sobre campo não inicializado.

Existe uma maneira de suprimir avisos do compilador de uma forma mais sofisticada? Posso usar o Roslyn para afetar de alguma forma o diagnóstico do compilador?

c#

2 respostas

  1. Best Answer

    Como @marc-gravell mencionou, há uma DiagnosticSuppressorAPI no Roslyn. Eu a usei para coisas semelhantes. Ela funciona até mesmo se você adicionar o analisador com o supressor ao seu projeto como um pacote nuget.

    Há uma desvantagem, porém, o Rider IDE não suporta essa funcionalidade do Roslyn. Então, use-o por sua conta e risco.

    Quanto ao código, ele deve ficar assim:

    using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;

namespace NullableDiagnosticHider
{
    /// <summary>
    /// Customized version of CS8524 diagnostic which is the one reported by C# compiler in this case.
    /// </summary>
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class NullableDiagnosticHider : DiagnosticSuppressor
    {
        public static readonly SuppressionDescriptor NonNullableUninitializedAfterConstructorDiagnostic =
            new SuppressionDescriptor("PXS001", "CS8618", "<Describe the reason for suppression>");
   
        public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions { get; } = ImmutableArray.Create(NonNullableUninitializedAfterConstructorDiagnostic);
    
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            if (context.ReportedDiagnostics.IsDefaultOrEmpty)
                return;
    
            foreach (Diagnostic diagnostic in context.ReportedDiagnostics)
            {
                context.CancellationToken.ThrowIfCancellationRequested();
                SuppressNullableDiagnostic(context, diagnostic);
            }
        }

        private static void SuppressNullableDiagnostic(SuppressionAnalysisContext context, Diagnostic diagnostic)
        {
            if (diagnostic.IsSuppressed || diagnostic.Location.SourceTree is not { } syntaxTree)
                return;

            SyntaxNode? root = syntaxTree.GetRoot(context.CancellationToken);
            var diagnosticNode = root?.FindNode(diagnostic.Location.SourceSpan);

            // For the given case it makes sense to check if the syntax node is one of the possible member declaration nodes that may have the compiler warning 
            if (diagnosticNode is not (ConstructorDeclarationSyntax or VariableDeclaratorSyntax or PropertyDeclarationSyntax) ||
                context.GetSemanticModel(syntaxTree) is not SemanticModel semanticModel)
            {
                return;
            }

            if (semanticModel.GetDeclaredSymbol(diagnosticNode, context.CancellationToken) is not { } memberSymbol)
            {
                return;
            }
            
            if (MemberMeetsSuppressionConditions(memberSymbol, diagnostic, context.CancellationToken))
            {
                var suppression = Suppression.Create(NonNullableUninitializedAfterConstructorDiagnostic, diagnostic);
                context.ReportSuppression(suppression);
            }
        }
    
        private static bool MemberMeetsSuppressionConditions(ISymbol memberSymbol, Diagnostic diagnostic, CancellationToken cancellation)
        {
            // Put your logic to recognize the symbol to be not suppressed here.
            // For special types this is usually a check for base types and implemented interfaces 
            // For diagnostics on constructors you may need to use AdditionalLocations property from the `diagnostic`
           // that contains the location of the uninitialized field/property
        }
    }
}
    • 5

  2. Você mencionou Roslyn; se você estiver feliz em chegar ao nível de escrever seu próprio analisador que pode identificar os cenários permitidos, então: o que você está procurando é DiagnosticSuppressor.

    Observe que somente avisos (não erros) podem ser suprimidos.

    • 3

relate perguntas