< Summary

Information
Class: AsiBackbone.Analyzers.GovernanceArtifactPersistenceAnalyzer
Assembly: AsiBackbone.Analyzers
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Analyzers/GovernanceArtifactPersistenceAnalyzer.cs
Line coverage
98%
Covered lines: 106
Uncovered lines: 2
Coverable lines: 108
Total lines: 229
Line coverage: 98.1%
Branch coverage
86%
Covered branches: 86
Total branches: 100
Branch coverage: 86%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()50%44100%
get_SupportedDiagnostics()100%11100%
Initialize(...)100%11100%
AnalyzeExpressionStatement(...)100%88100%
AnalyzeDiscardAssignment(...)100%1010100%
UnwrapAwait(...)100%22100%
IsArtifactProducerOperation(...)88.89%181894.12%
IsPersistenceBoundaryInvocation(...)100%66100%
IsPersistenceBoundaryType(...)100%11100%
GetGovernanceArtifactType(...)75%4480%
UnwrapKnownWrapper(...)85%2020100%
IsKnownAsyncWrapper(...)71.43%1414100%
IsSuppressedByHostMarker(...)85.71%1414100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Analyzers/GovernanceArtifactPersistenceAnalyzer.cs

#LineLine coverage
 1using System.Collections.Immutable;
 2using Microsoft.CodeAnalysis;
 3using Microsoft.CodeAnalysis.Diagnostics;
 4using Microsoft.CodeAnalysis.Operations;
 5
 6namespace AsiBackbone.Analyzers;
 7
 8/// <summary>
 9/// Reports governance artifacts, such as decisions, decision receipts, capability grant results, and outbox entries,
 10/// that are created or returned and then discarded without persistence, emission, or a host-owned continuation.
 11/// </summary>
 12/// <remarks>
 13/// Members annotated with an <c>AsiBackbonePersistenceHandled</c> attribute are treated as deliberate host-owned
 14/// continuation paths and are not reported.
 15/// </remarks>
 16[DiagnosticAnalyzer(LanguageNames.CSharp)]
 17public sealed class GovernanceArtifactPersistenceAnalyzer : DiagnosticAnalyzer
 18{
 19    /// <summary>
 20    /// Gets the diagnostic identifier reported when a governance artifact is created or returned and then discarded.
 21    /// </summary>
 22    public const string DiagnosticId = "ASIB001";
 23
 124    private static readonly DiagnosticDescriptor Rule = new(
 125        DiagnosticId,
 126        "Persist or continue AsiBackbone governance artifact",
 127        "AsiBackbone governance artifact '{0}' is created or returned and then discarded; persist the decision receipt o
 128        "AsiBackbone.GovernanceSafety",
 129        DiagnosticSeverity.Warning,
 130        isEnabledByDefault: true,
 131        description: "Governance decisions, decision receipts, capability grants, acknowledgment outcomes, and outbox ar
 32
 133    private static readonly ImmutableHashSet<string> GovernanceArtifactTypeNames = ImmutableHashSet.Create(
 134        StringComparer.Ordinal,
 135        "AsiBackbone.Core.Audit.AuditLedgerRecord",
 136        "AsiBackbone.Core.Audit.DecisionReceipt",
 137        "AsiBackbone.Core.CapabilityTokens.CapabilityGrantUseResult",
 138        "AsiBackbone.Core.CapabilityTokens.CapabilityGrantValidationResult",
 139        "AsiBackbone.Core.CapabilityTokens.CapabilityTokenGrant",
 140        "AsiBackbone.Core.Decisions.GovernanceDecision",
 141        "AsiBackbone.Core.Emissions.GovernanceEmissionEnvelope",
 142        "AsiBackbone.Core.Emissions.GovernanceEmissionResult",
 143        "AsiBackbone.Core.Handshakes.LiabilityHandshakeAcknowledgment",
 144        "AsiBackbone.Core.Outbox.GovernanceOutboxEntry");
 45
 146    private static readonly ImmutableHashSet<string> PersistenceBoundaryTypeNames = ImmutableHashSet.Create(
 147        StringComparer.Ordinal,
 148        "AsiBackbone.Core.Audit.IGovernanceAuditLedgerStore",
 149        "AsiBackbone.Core.Audit.IDecisionReceiptLifecycleStore",
 150        "AsiBackbone.Core.Audit.IDecisionReceiptSink",
 151        "AsiBackbone.Core.CapabilityTokens.ICapabilityGrantUseStore",
 152        "AsiBackbone.Core.Outbox.IGovernanceOutboxStore");
 53
 54    /// <summary>
 55    /// Gets the diagnostics supported by this analyzer.
 56    /// </summary>
 4557    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
 58
 59    /// <summary>
 60    /// Initializes the analyzer and registers operation analysis for discarded expression statements and discard
 61    /// assignments.
 62    /// </summary>
 63    /// <param name="context">The analysis context used to register analyzer actions.</param>
 64    public override void Initialize(AnalysisContext context)
 65    {
 4566        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 4567        context.EnableConcurrentExecution();
 4568        context.RegisterOperationAction(AnalyzeExpressionStatement, OperationKind.ExpressionStatement);
 4569        context.RegisterOperationAction(AnalyzeDiscardAssignment, OperationKind.SimpleAssignment);
 4570    }
 71
 72    private static void AnalyzeExpressionStatement(OperationAnalysisContext context)
 73    {
 6574        var expressionStatement = (IExpressionStatementOperation)context.Operation;
 75
 6576        if (IsSuppressedByHostMarker(context.ContainingSymbol) || expressionStatement.Operation is ISimpleAssignmentOper
 77        {
 2978            return;
 79        }
 80
 3681        IOperation expression = UnwrapAwait(expressionStatement.Operation);
 3682        ITypeSymbol? artifactType = GetGovernanceArtifactType(expression.Type);
 3683        if (artifactType is null || !IsArtifactProducerOperation(expression))
 84        {
 2585            return;
 86        }
 87
 1188        context.ReportDiagnostic(
 1189            Diagnostic.Create(
 1190                Rule,
 1191                expression.Syntax.GetLocation(),
 1192                artifactType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
 1193    }
 94
 95    private static void AnalyzeDiscardAssignment(OperationAnalysisContext context)
 96    {
 2797        var assignment = (ISimpleAssignmentOperation)context.Operation;
 98
 2799        if (IsSuppressedByHostMarker(context.ContainingSymbol)
 27100            || (assignment.Target is not IDiscardOperation && !IsKnownAsyncWrapper(assignment.Value.Type)))
 101        {
 4102            return;
 103        }
 104
 23105        IOperation value = UnwrapAwait(assignment.Value);
 23106        ITypeSymbol? artifactType = GetGovernanceArtifactType(value.Type);
 23107        if (artifactType is null || !IsArtifactProducerOperation(value))
 108        {
 10109            return;
 110        }
 111
 13112        context.ReportDiagnostic(
 13113            Diagnostic.Create(
 13114                Rule,
 13115                assignment.Syntax.GetLocation(),
 13116                artifactType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
 13117    }
 118
 119    private static IOperation UnwrapAwait(IOperation operation)
 120    {
 104121        return operation is IAwaitOperation awaitOperation
 104122            ? awaitOperation.Operation
 104123            : operation;
 124    }
 125
 126    private static bool IsArtifactProducerOperation(IOperation? operation)
 127    {
 45128        if (operation is null)
 129        {
 0130            return false;
 131        }
 132
 45133        operation = UnwrapAwait(operation);
 134
 46135        while (operation is IConversionOperation conversionOperation)
 136        {
 1137            operation = conversionOperation.Operand;
 1138        }
 139
 45140        return operation switch
 45141        {
 20142            IInvocationOperation invocationOperation => !IsPersistenceBoundaryInvocation(invocationOperation),
 5143            IObjectCreationOperation => true,
 2144            IPropertyReferenceOperation => true,
 4145            IConditionalOperation conditionalOperation => IsArtifactProducerOperation(conditionalOperation.WhenTrue)
 4146                || IsArtifactProducerOperation(conditionalOperation.WhenFalse),
 3147            ICoalesceOperation coalesceOperation => IsArtifactProducerOperation(coalesceOperation.Value)
 3148                || IsArtifactProducerOperation(coalesceOperation.WhenNull),
 11149            _ => false
 45150        };
 151    }
 152
 153    private static bool IsPersistenceBoundaryInvocation(IInvocationOperation invocation)
 154    {
 20155        return invocation.Instance?.Type is INamedTypeSymbol receiverType
 20156            && (IsPersistenceBoundaryType(receiverType)
 20157                || receiverType.AllInterfaces.Any(IsPersistenceBoundaryType));
 158    }
 159
 160    private static bool IsPersistenceBoundaryType(INamedTypeSymbol type)
 161    {
 7162        string typeName = type.OriginalDefinition.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
 7163        return PersistenceBoundaryTypeNames.Contains(typeName);
 164    }
 165
 166    private static ITypeSymbol? GetGovernanceArtifactType(ITypeSymbol? type)
 167    {
 59168        ITypeSymbol? candidate = UnwrapKnownWrapper(type);
 59169        if (candidate is null)
 170        {
 0171            return null;
 172        }
 173
 59174        string candidateName = candidate.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
 59175        return GovernanceArtifactTypeNames.Contains(candidateName) ? candidate : null;
 176    }
 177
 178    private static ITypeSymbol? UnwrapKnownWrapper(ITypeSymbol? type)
 179    {
 70180        while (type is INamedTypeSymbol { IsGenericType: true, TypeArguments.Length: 1 } namedType)
 181        {
 12182            string namespaceName = namedType.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessage
 183
 12184            if ((namespaceName == "System.Threading.Tasks" && (namedType.Name == "Task" || namedType.Name == "ValueTask"
 12185                || (namespaceName == "AsiBackbone.Core.Results" && namedType.Name == "OperationResult"))
 186            {
 11187                type = namedType.TypeArguments[0];
 11188                continue;
 189            }
 190
 191            break;
 192        }
 193
 59194        return type;
 195    }
 196
 197    private static bool IsKnownAsyncWrapper(ITypeSymbol? type)
 198    {
 6199        if (type is not INamedTypeSymbol { IsGenericType: true, TypeArguments.Length: 1 } namedType)
 200        {
 2201            return false;
 202        }
 203
 4204        string namespaceName = namedType.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageForm
 4205        return namespaceName == "System.Threading.Tasks" && (namedType.Name == "Task" || namedType.Name == "ValueTask");
 206    }
 207
 208    private static bool IsSuppressedByHostMarker(ISymbol? symbol)
 209    {
 366210        for (ISymbol? current = symbol; current is not null; current = current.ContainingSymbol)
 211        {
 370212            foreach (AttributeData attribute in current.GetAttributes())
 213            {
 4214                string? attributeName = attribute.AttributeClass?.Name;
 4215                if (attributeName is "AsiBackbonePersistenceHandled" or "AsiBackbonePersistenceHandledAttribute")
 216                {
 4217                    return true;
 218                }
 219            }
 220
 179221            if (current is INamedTypeSymbol)
 222            {
 223                break;
 224            }
 225        }
 226
 88227        return false;
 228    }
 229}