GCが発生するIReadOnlyList<T>等のforeachに警告を出すRoslynAnalyzer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;

namespace MyAnalyzer;

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class ForeachGcAnalyzer : DiagnosticAnalyzer
{
    public const string DiagnosticId = "GCFOREACH001";
    private static readonly LocalizableString Title = "GC アロケーションを伴う foreach";
    private static readonly LocalizableString MessageFormat = "この foreach は GC ヒープに IEnumerator を確保します。for ループや Span<T> の利用を検討してください";
    private static readonly LocalizableString Description = "参照型 IEnumerator または boxing が発生する foreach を検出して警告します。";
    private const string Category = "Performance";

    private static readonly DiagnosticDescriptor Rule = new(
        DiagnosticId,
        Title,
        MessageFormat,
        Category,
        DiagnosticSeverity.Warning,
        isEnabledByDefault: true,
        description: Description
    );

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);

    public override void Initialize(AnalysisContext context)
    {
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();
        context.RegisterSyntaxNodeAction(AnalyzeForeach, SyntaxKind.ForEachStatement);
    }

    private static void AnalyzeForeach(SyntaxNodeAnalysisContext context)
    {
        var foreachStmt = (ForEachStatementSyntax) context.Node;
        var model = context.SemanticModel;
        var info = model.GetForEachStatementInfo(foreachStmt);
        var collectionType = model.GetTypeInfo(foreachStmt.Expression).Type;

        if (collectionType == null) return;

        if (ShouldWarn(info, collectionType))
        {
            var diag = Diagnostic.Create(Rule, foreachStmt.ForEachKeyword.GetLocation());
            context.ReportDiagnostic(diag);
        }
    }

    private static bool ShouldWarn(ForEachStatementInfo info, ITypeSymbol collectionType)
    {
        if (collectionType is IArrayTypeSymbol)
        {
            return false;
        }

        if (collectionType.SpecialType == SpecialType.System_String)
        {
            return false;
        }

        var enumeratorType = info.GetEnumeratorMethod?.ReturnType;
        if (enumeratorType == null)
        {
            return false;
        }

        if (enumeratorType.IsReferenceType)
        {
            return true;
        }

        if (enumeratorType.IsValueType)
        {
            switch (collectionType.TypeKind)
            {
                case TypeKind.Interface:
                case TypeKind.Dynamic:
                    return true;
            }

            if (collectionType.SpecialType == SpecialType.System_Object)
            {
                return true;
            }

            return false;
        }

        return true;
    }
}