Custom Analyzer not detecting deprecated property #79120

iram25484 · 2025-06-24T08:55:04Z

iram25484
Jun 24, 2025

What I'm trying to do

I’m working with a custom Roslyn analyzer in a C# project . The goal is to detect deprecated APIs marked with a custom [DeprecatedApi] attribute and flag their usage during development.

We are using this to enforce newer API usages across our framework and platform code.

Here is the code for the analyser :

using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;

namespace Philips.AV.RoslynAnalyzers
{
[DiagnosticAnalyzer("C#", new string[] { })]
public class DeprecatedApiAnalyzerAnalyzer : DiagnosticAnalyzer
{
public const string DiagnosticId = "AV2002";

	private static readonly LocalizableString Title = "This has been deprecated";

	private static readonly LocalizableString MessageFormat = "This has or will be deprecated. '{0}'";

	private static readonly LocalizableString Description = "Deprecated code should not be used";

	private const string Category = "Naming";

	private const string AttributeToCheck = "DeprecatedApiAttribute";

	private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor("AV2002", Title, MessageFormat, "Naming", DiagnosticSeverity.Error, true, Description, null);

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

	public override void Initialize(AnalysisContext context)
	{
		context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
		context.EnableConcurrentExecution();
		context.RegisterSymbolAction(AnalyzeSymbolGeneral, SymbolKind.Method, SymbolKind.Property, SymbolKind.Field);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeMethodInvocation, SyntaxKind.InvocationExpression);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeObjectCreationExpression, SyntaxKind.ObjectCreationExpression);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeMemberAccessExpression, SyntaxKind.SimpleMemberAccessExpression);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeLocalDeclarationExpression, SyntaxKind.LocalDeclarationStatement);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeFieldDeclaration, SyntaxKind.FieldDeclaration);
		context.RegisterSyntaxNodeAction<SyntaxKind>(AnalyzeInterfaceDeclaration, SyntaxKind.SimpleBaseType);
	}

	private static void AnalyzeSymbolGeneral(SymbolAnalysisContext context)
	{
		ISymbol symbol = context.Symbol;
		AttributeData attributeData = symbol.GetAttributes().FirstOrDefault((AttributeData a) => a.AttributeClass.Name == "DeprecatedApiAttribute");
		if (attributeData != null)
		{
			string text = attributeData.ConstructorArguments[0].Value as string;
			Diagnostic diagnostic = Diagnostic.Create(Rule, symbol.Locations[0], text);
			context.ReportDiagnostic(diagnostic);
		}
	}

	private void AnalyzeMethodInvocation(SyntaxNodeAnalysisContext context)
	{
		InvocationExpressionSyntax invocationExpressionSyntax = (InvocationExpressionSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(invocationExpressionSyntax.Expression).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, invocationExpressionSyntax.Expression.GetLocation());
		}
	}

	private void AnalyzeObjectCreationExpression(SyntaxNodeAnalysisContext context)
	{
		ObjectCreationExpressionSyntax objectCreationExpressionSyntax = (ObjectCreationExpressionSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(objectCreationExpressionSyntax).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, objectCreationExpressionSyntax.GetLocation());
		}
	}

	private void AnalyzeMemberAccessExpression(SyntaxNodeAnalysisContext context)
	{
		MemberAccessExpressionSyntax memberAccessExpressionSyntax = (MemberAccessExpressionSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(memberAccessExpressionSyntax.Expression).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, memberAccessExpressionSyntax.Expression.GetLocation());
		}
	}

	private void AnalyzeLocalDeclarationExpression(SyntaxNodeAnalysisContext context)
	{
		LocalDeclarationStatementSyntax localDeclarationStatementSyntax = (LocalDeclarationStatementSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(localDeclarationStatementSyntax.Declaration).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, localDeclarationStatementSyntax.GetLocation());
		}
	}

	private void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
	{
		FieldDeclarationSyntax fieldDeclarationSyntax = (FieldDeclarationSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(fieldDeclarationSyntax.Declaration).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, fieldDeclarationSyntax.Declaration.GetLocation());
		}
	}

	private void AnalyzeInterfaceDeclaration(SyntaxNodeAnalysisContext context)
	{
		SimpleBaseTypeSyntax simpleBaseTypeSyntax = (SimpleBaseTypeSyntax)context.Node;
		ISymbol symbol = context.SemanticModel.GetSymbolInfo(simpleBaseTypeSyntax).Symbol;
		if (symbol != null)
		{
			CheckForDeprecatedApiAttribute(context, symbol, simpleBaseTypeSyntax.GetLocation());
		}
	}

	private void CheckForDeprecatedApiAttribute(SyntaxNodeAnalysisContext context, ISymbol symbol, Location errorLocation)
	{
		AttributeData attributeData = symbol.GetAttributes().FirstOrDefault((AttributeData a) => (a.AttributeClass.Name == "DeprecatedApiAttribute")||(a.AttributeClass.Name =="DeprecatedApi"));
		if (attributeData != null)
		{
			object value = attributeData.ConstructorArguments[0].Value;
			Diagnostic diagnostic = Diagnostic.Create(Rule, errorLocation, value);
			context.ReportDiagnostic(diagnostic);
		}
	}
}

}

The Problem

Our analyzer fails to detect usage of a deprecated property when it’s accessed via a conditional access expression, like:

if (bitVol?.BitsCount > 0)
In this case, BitsCount is marked with [DeprecatedApi("Use GetBitsCount(token) instead")], but the analyzer doesn’t flag it.

an example code where it is not working is below :

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
using GfnServices;
using Philips.AV.Framework.Common;
using Philips.Platform.DataModels;
using Philips.Platform.DataModels.Mathematics;

namespace Philips.AV.Framework.SuiteHosting
{
///

/// The statistics for a finding
///

[DataContract]
public class TissueStatistic
{
///

/// Volume of the given finding
///

[DataMember]
public double VolumeSize { get; set; }

    /// <summary>
    ///     Mean value of a given finding
    /// </summary>
    [DataMember]
    public double MeanValue { get; set; }

    /// <summary>
    ///     std value of a given finding
    /// </summary>
    [DataMember]
    public double StdValue { get; set; }

    /// <summary>
    ///     Max value of a given finding
    /// </summary>
    [DataMember]
    public double MaxValue { get; set; }

    /// <summary>
    ///     Min value of a given finding
    /// </summary>
    [DataMember]
    public double MinValue { get; set; }

    /// <summary>
    ///     Max value of a 3D Diameter (3d max diameter)s
    /// </summary>
    [DataMember]
    public double MaxDiameter { get; set; }

    /// <summary>
    ///     Max value of a 2D Diameter (long)
    /// </summary>
    [DataMember]
    public double MaxSecondaryDiameter { get; set; }

    /// <summary>
    ///     Max value of a perpendicular 2D Diameter (short)
    /// </summary>
    [DataMember]
    public double MaxPerpendicularDiameter { get; set; }

    /// <summary>
    ///     BoundingBox enclosed by the Finding
    /// </summary>
    [DataMember]
    public Point3D[] BoundingBoxParams { get; set; }

    /// <summary>
    ///     Units of a given finding
    /// </summary>
    [DataMember]
    public string Units { get; set; }

    /// <summary>
    ///     two Point3D in Patient domain of long diameter Pos.
    /// </summary>
    [DataMember]
    public Point3D[] MaxSecondaryDiameterPos { get; set; }

    /// <summary>
    ///     two Point3D in Patient domain of short diameter Pos.
    /// </summary>
    [DataMember]
    public Point3D[] MaxPerpendicularDiameterPos { get; set; }
}

/// <summary>
///     Utility to calculate the tissue stats
/// </summary>
public static class TissueStatsCalculatorUtil
{
    public static readonly float SphereRadiusMM = 6.2f; // r = (3/4*pi)^(1/3)
    private static readonly ILog Log = LogManager.GetLogger();

    public static TissueStatistics CalculateTissueStatistics(
        IVolume volume,
        BitVol bitVol,
        Rescale rescale)
    {
        TissueStatistics[] stats = CalculateTissueStatistics(
            new[] { volume },
            new[] { bitVol },
            new[] { string.Empty },
            new[] { string.Empty },
            new[] { false },
            new[] { rescale },
            false);
        return stats != null && stats.Length > 0 ? stats[0] : null;
    }

    private static TissueStatistics[] CalculateTissueStatistics(IVolume[] volumes, BitVol[] bitVols, string[] parameters, string[] units, bool[] calculatePeakSUL, Rescale[] rescales, bool onTumourDiameterCalculation)
    {
        var stats = new TissueStatistics[volumes.Length];

        for (var i = 0; i < volumes.Length; i++)
        {
            if (volumes[i] != null && bitVols[i] != null)
            {
                var stat = new TissueStatistics();
                _ = CalculateTissueStatistics(volumes[i], bitVols[i], stat, parameters[i], units[i], calculatePeakSUL[i], rescales[i], onTumourDiameterCalculation);
                stats[i] = stat;
            }
            else
            {
                stats[i] = null;
            }
        }

        return stats;
    }

    [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
    private static TissueStatistics CalculateTissueStatistics(IVolume vol, BitVol bitVol, TissueStatistics stats, string parameter, string units, bool calculatePeakSUL, Rescale rescale, bool onTumourDiameterCalculation)
    {
        if (bitVol != null || vol != null)
        {
            var voxelCount = 0;
            int meanX = 0, meanY = 0, meanZ = 0;
            int minx, miny, minz;
            int maxx = 0, maxy = 0, maxz = 0;
            int bbOffsetX = 0, bbOffsetY = 0, bbOffsetZ = 0;
            int bbSizeX = 0, bbSizeY = 0, bbSizeZ = 0;
            var maxSliceVoxels = 0;

            // int indexMaxValueZ = 0;
            double volumeSize = double.NaN;
            double maxDiameter = double.NaN;
            double maxSecondaryDiameter = double.NaN;
            Point3D[] maxSecondaryDiameterPos = null;
            double maxPerpendicularDiameter = double.NaN;
            Point3D[] maxPerpendicularDiameterPos = null;

            // double effDiameter = Double.NaN;
            double meanPixelValue = 0, huSquareSum = 0;
            double stdPixelValue = 0;
            double maxPixelValue = double.MinValue;
            double minPixelValue = double.MaxValue;

            // double volumeErrorSize = 0;
            double peakSULStoredValue = double.MinValue;
            int[] peakSULValueCenter = null;

            // TODO : enable this in future if required
            // Histogram histogram = null;
            try
            {
                using (var readLockToken = bitVol.ReadLock())
                {
                    if (bitVol?.BitsCount > 0)
                    {
                        bitVol.ComputeBoundingBox(readLockToken, out bbOffsetX, out bbOffsetY, out bbOffsetZ, out bbSizeX, out bbSizeY, out bbSizeZ);
                    }
                }

                Point3D[] boundingBoxVecs =
                {
                    new Point3D(bbOffsetX, bbOffsetY, bbOffsetZ),
                    new Point3D(bbOffsetX + bbSizeX, bbOffsetY, bbOffsetZ),
                    new Point3D(bbOffsetX, bbOffsetY + bbSizeY, bbOffsetZ),
                    new Point3D(bbOffsetX, bbOffsetY, bbOffsetZ + bbSizeZ)
                };

                for (var i = 0; i < boundingBoxVecs.Length; i++)
                {
                    boundingBoxVecs[i] *= vol.Patient2StackMatrix.Inverse;
                }

                stats.BoundingBoxParams = boundingBoxVecs;

                if (bbOffsetX >= 0 && bbOffsetY >= 0 && bbOffsetZ >= 0 &&
                    bbSizeX >= 0 && bbSizeY >= 0 && bbSizeZ >= 0)
                {
                    minx = bitVol.X;
                    miny = bitVol.Y;
                    minz = bitVol.Z;

                    // first pass - calculate total voxels, max voxels in slice, mean
                    for (int z = bbOffsetZ; z <= bbOffsetZ + bbSizeZ; z++)
                    {
                        IImage img = z < vol.Images.Count ? vol.Images[z] : vol.Images[vol.Images.Count - 1];
                        using (var imageAccess = new ImageAccess(img.ImagePixels, rescale))
                        {
                            var sliceVoxelCount = 0;

                            using (var readLockToken = bitVol.ReadLock())
                            {
                                for (int x = bbOffsetX; x <= bbOffsetX + bbSizeX; x++)
                                {
                                    for (int y = bbOffsetY; y < bbOffsetY + bbSizeY; y++)
                                    {
                                        if (bitVol.GetBit(readLockToken, x, y, z))
                                        {
                                            // total voxel count
                                            voxelCount++;
                                            sliceVoxelCount++;

                                            // mean
                                            meanX += x;
                                            meanY += y;
                                            meanZ += z;

                                            // real bounds
                                            if (x < minx)
                                            {
                                                minx = x;
                                            }

                                            if (y < miny)
                                            {
                                                miny = y;
                                            }

                                            if (z < minz)
                                            {
                                                minz = z;
                                            }

                                            if (x > maxx)
                                            {
                                                maxx = x;
                                            }

                                            if (y > maxy)
                                            {
                                                maxy = y;
                                            }

                                            if (z > maxz)
                                            {
                                                maxz = z;
                                            }

                                            // process HU
                                            double pixelValue = imageAccess.GetPixel(x, y);
                                            pixelValue = rescale.ToRealValue(pixelValue);
                                            huSquareSum += pixelValue * pixelValue;
                                            meanPixelValue += pixelValue;

                                            if (pixelValue > maxPixelValue)
                                            {
                                                maxPixelValue = pixelValue;

                                                // indexMaxValueZ = z;
                                            }

                                            if (pixelValue < minPixelValue)
                                            {
                                                minPixelValue = pixelValue;
                                            }
                                        }
                                    }
                                }
                            }

                            // maintain biggest voxel number in a single slice
                            if (sliceVoxelCount > maxSliceVoxels)
                            {
                                maxSliceVoxels = sliceVoxelCount;

                                // indexMaxAreaZ = z;
                            }
                        }
                    }

#pragma warning disable PH2097 // Avoid empty statement blocks

                    // TODO : Need to enable this in future if required
                    if (!string.IsNullOrEmpty(parameter) && voxelCount > 0 && minPixelValue < maxPixelValue)
                    {
                        // histogram = TissueStatsWrapper.Instance.CreateHistogram(minPixelValue, maxPixelValue, parameter);
                        //    FillTissueHistogram(vol, bitVol, histogram, rescale);
                    }

#pragma warning restore PH2097 // Avoid empty statement blocks

                    // empty BitVol ?? - nothing to do
                    if (voxelCount == 0)
                    {
                        volumeSize = 0.0;

                        // effDiameter = 0.0;
                        maxDiameter = 0.0;
                        maxSecondaryDiameter = 0.0;
                        maxPerpendicularDiameter = 0.0;
                        meanPixelValue = 0;
                        stdPixelValue = 0;
                        minPixelValue = 0;
                        maxPixelValue = 0;
                    }
                    else
                    {
                        meanX /= voxelCount;
                        meanY /= voxelCount;
                        meanZ /= voxelCount;

                        // volume
                        volumeSize = voxelCount * GetVoxelVolume(vol.Geometry);

                        // effective diameter
                        // double volR = Math.Pow(Math.Abs(volumeSize) / (4.0 / 3.0 * Math.PI), 1.0 / 3.0);
                        // effDiameter = 2.0 * volR;
                        meanPixelValue /= voxelCount;

                        // Compute the Standard deviation of Hounsfield Units
                        stdPixelValue = Math.Sqrt((huSquareSum / voxelCount) - (meanPixelValue * meanPixelValue));

                        // int indexMaxAreaZ = 0;
                        ComputeDiameter(vol, bitVol, meanX, meanY, meanZ, minx, miny, minz, maxx, maxy, maxz, onTumourDiameterCalculation, out maxDiameter, out maxSecondaryDiameter, out maxSecondaryDiameterPos, out maxPerpendicularDiameter, out maxPerpendicularDiameterPos, out int indexMaxDiameterZ);

                        // volumeErrorSize = bitVol.Boundary6BitsCount * GetVoxelVolume(vol.Geometry) / 4; // 1/2 Voxel is the max 1/4 is the average
                    }
                }

                if (calculatePeakSUL)
                {
                    peakSULValueCenter =
                        CalculatePercistPeakValue(vol, bitVol, SphereRadiusMM, out peakSULStoredValue);
                }
            }
            catch (Exception)
            {
                Log.Error("CalculateTissueStatistics Tissue statistics calculation failed");
            }

            // Preparing the TissueStatistis object
            if (maxSecondaryDiameterPos != null)
            {
                maxSecondaryDiameterPos[0] *= vol.Patient2StackMatrix.Inverse;
                maxSecondaryDiameterPos[1] *= vol.Patient2StackMatrix.Inverse;
            }

            if (maxPerpendicularDiameterPos != null)
            {
                maxPerpendicularDiameterPos[0] *= vol.Patient2StackMatrix.Inverse;
                maxPerpendicularDiameterPos[1] *= vol.Patient2StackMatrix.Inverse;
            }

            // TODO : Need to enable this in future if required
            stats.VolumeSize = volumeSize / 1000.0;

            // stats.MinDiameter = Double.NaN;
            stats.MaxDiameter = maxDiameter;
            stats.MaxSecondaryDiameter = maxSecondaryDiameter;
            stats.MaxSecondaryDiameterPos = maxSecondaryDiameterPos;
            stats.MaxPerpendicularDiameter = maxPerpendicularDiameter;
            stats.MaxPerpendicularDiameterPos = maxPerpendicularDiameterPos;

            // stats.EffDiameter = effDiameter;
            // stats.VolumeErrorSize = volumeErrorSize / 1000.0;
            //// max area in single slice
            // stats.MaxArea = maxSliceVoxels * vol.Box.XmmPerPixel * vol.Box.YmmPerPixel / 100.0;

            // Point3D vectorTransformToPhysical = new Point3D(meanX, meanY, indexMaxAreaZ);
            // vectorTransformToPhysical = vectorTransformToPhysical * vol.Box.InvTransform;
            // stats.MaxAreaZ = vectorTransformToPhysical.Z;

            // vectorTransformToPhysical = new Point3D(meanX, meanY, indexMaxValueZ);
            // vectorTransformToPhysical = vectorTransformToPhysical * vol.Box.InvTransform;
            // stats.MaxValueZ = vectorTransformToPhysical.Z;

            // vectorTransformToPhysical = new Point3D(meanX, meanY, indexMaxDiameterZ);
            // vectorTransformToPhysical = vectorTransformToPhysical * vol.Box.InvTransform;
            // stats.MaxDiameterZ = vectorTransformToPhysical.Z;
            // stats.Histogram = histogram;

#pragma warning disable PH2097 // Avoid empty statement blocks
if (peakSULValueCenter != null && peakSULStoredValue != double.MinValue)
{
// double peakSULModalityValue = rescale.ToRealValue(peakSULStoredValue);
// Point3D centerStack = new Point3D(peakSULValueCenter[0], peakSULValueCenter[1], peakSULValueCenter[2]);
// Point3D centerPhys = centerStack * vol.Box.InvTransform;
// if (stats.PeakSULModel != null)
// {
// stats.PeakSULModel.PeakSULCenterPhys = centerPhys;
// stats.PeakSULModel.PeakSULMeanValue = peakSULModalityValue;
// }
// else
// {
// stats.PeakSULModel = new PeakSULModel(centerPhys, peakSULModalityValue);
// }
}
#pragma warning restore PH2097 // Avoid empty statement blocks
stats.MeanValue = meanPixelValue;
stats.StdValue = stdPixelValue;
stats.MaxValue = maxPixelValue;
stats.MinValue = minPixelValue;
stats.Units = units;

            // TODO : Need to enable this in future if required
            // if (indexMaxDiameterZ >= 0 && vol.Images.Count > indexMaxDiameterZ && vol.Images[indexMaxDiameterZ].ImageIOD != null &&
            //    vol.Images[indexMaxDiameterZ].ImageIOD.GeneralImageModule != null &&
            //    vol.Images[indexMaxDiameterZ].ImageIOD.GeneralImageModule.HasInstanceNumber == Dicom.DicomAttributeStatus.HasValue)
            // {
            //    stats.SliceNumber = vol.Images[indexMaxDiameterZ].ImageIOD.GeneralImageModule.InstanceNumber;
            //    stats.SeriesNumber = vol.Images[indexMaxDiameterZ].ImageIOD.GeneralSeriesModule.SeriesNumber;
            // }
            // else
            // {
            //    stats.SliceNumber = -1;
            // }
        }

        return stats;
    }

    // private static void FillTissueHistogram(IVolume vol, BitVol bitVol, Histogram histogram, Rescale rescale)
    // {
    //    if ((bitVol != null) || (vol != null))
    //    {
    //        int bbOffsetX = 0, bbOffsetY = 0, bbOffsetZ = 0;
    //        int bbSizeX = 0, bbSizeY = 0, bbSizeZ = 0;

    // try
    //        {
    //            if (bitVol.BitsCount > 0)
    //            {
    //                bitVol.ComputeBoundingBox(out bbOffsetX, out bbOffsetY, out bbOffsetZ, out bbSizeX, out bbSizeY, out bbSizeZ);
    //            }

    // if ((bbOffsetX >= 0) && (bbOffsetY >= 0) && (bbOffsetZ >= 0) &&
    //                (bbSizeX >= 0) && (bbSizeY >= 0) && (bbSizeZ >= 0))
    //            {
    //                // fill the histogram
    //                for (int z = bbOffsetZ; z <= bbOffsetZ + bbSizeZ; z++)
    //                {
    //                    IImage img = (z < vol.Images.Count) ? vol.Images[z] : vol.Images[vol.Images.Count - 1];
    //                    using (ImageAccess imageAccess = new ImageAccess(img.ImagePixels, rescale))
    //                    {
    //                        for (int x = bbOffsetX; x <= bbOffsetX + bbSizeX; x++)
    //                        {
    //                            for (int y = bbOffsetY; y < bbOffsetY + bbSizeY; y++)
    //                            {
    //                                if (bitVol.GetBit(x, y, z))
    //                                {
    //                                    double storedValue = imageAccess.GetPixel(x, y);
    //                                    double modalityValue = rescale.ToRealValue(storedValue);
    //                                    histogram.CountValue(modalityValue);
    //                                }
    //                            }
    //                        }
    //                    }
    //                }
    //            }
    //        }
    //        catch (Exception)
    //        {
    //            LALogUtil.LogError("FillTissueStatisticsHistogram Tissue statistics - histogram creation failed");
    //        }
    //    }
    // }
    [SuppressMessage("Microsoft.Performance", "CA1809:AvoidExcessiveLocals")]
    [SuppressMessage("Microsoft.Maintainability", "CA1505:AvoidUnmaintainableCode")]
    [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]

#pragma warning disable PH2071
private static void ComputeDiameter(IVolume vol, BitVol bitVol, int meanX, int meanY, int meanZ, int minx, int miny, int minz, int maxx, int maxy, int maxz, bool onTumourDiameterCalculation, out double maxDiameter, out double maxSecondaryDiameter, out Point3D[] maxSecondaryDiameterPos, out double maxPerpendicularDiameter, out Point3D[] maxPerpendicularDiameterPos, out int indexMaxDiameterZ)
{
maxSecondaryDiameterPos = new Point3D[2];
maxPerpendicularDiameterPos = new Point3D[2];

        double xMM = vol.Geometry.XmmPerPixel;
        double yMM = vol.Geometry.YmmPerPixel;
        double zMM = vol.Geometry.ZmmPerPixel;

        // ================== calculate max diameter

        // get the most distant point from the center of the mass
        int p1x = 0, p1y = 0, p1z = 0;
        double maxDistSqr = 0;
        using (var readLockToken = bitVol.ReadLock())
        {
            for (int z = minz; z <= maxz; z++)
            {
                for (int y = miny; y <= maxy; y++)
                {
                    for (int x = minx; x <= maxx; x++)
                    {
                        if (bitVol.GetBit(readLockToken, x, y, z))
                        {
                            double dx = (x - meanX) * xMM;
                            double dy = (y - meanY) * yMM;
                            double dz = (z - meanZ) * zMM;
                            double distSqr = (dx * dx) + (dy * dy) + (dz * dz);
                            if (distSqr >= maxDistSqr)
                            {
                                maxDistSqr = distSqr;
                                p1x = x;
                                p1y = y;
                                p1z = z;
                            }
                        }
                    }
                }
            }
        }

        // get the most distant point from the first ponts
        maxDistSqr = 0;
        using (var readLockToken = bitVol.ReadLock())
        {
            for (int z = minz; z <= maxz; z++)
            {
                for (int y = miny; y <= maxy; y++)
                {
                    for (int x = minx; x <= maxx; x++)
                    {
                        if (bitVol.GetBit(readLockToken, x, y, z))
                        {
                            double dx = (x - p1x) * xMM;
                            double dy = (y - p1y) * yMM;
                            double dz = (z - p1z) * zMM;
                            double distSqr = (dx * dx) + (dy * dy) + (dz * dz);
                            if (distSqr >= maxDistSqr)
                            {
                                maxDistSqr = distSqr;
                            }
                        }
                    }
                }
            }
        }

        maxDiameter = Math.Sqrt(maxDistSqr);

        // ================== calculate RECIST longest diameter
        double maxAxialDistSqr = 0;
        int maxAxialDistZ = -1;
        var startx = 0;
        var starty = 0;
        var endx = 0;
        var endy = 0;

        int dimX = bitVol.X;
        int dimY = bitVol.Y;

        var xcoords = new List<int>();
        var ycoords = new List<int>();

        // find longest diameter in each slice and among all slices
        using (var readLockToken = bitVol.ReadLock())
        {
            for (int z = minz; z <= maxz; z++)
            {
                xcoords.Clear();
                ycoords.Clear();

                // find edge pixels
                for (int y = miny; y <= maxy; y++)
                {
                    for (int x = minx; x <= maxx; x++)
                    {
                        if (bitVol.GetBit(readLockToken, x, y, z) &&
                            (x - 1 < 0 || x + 1 >= dimX ||
                             y - 1 < 0 || y + 1 >= dimY ||
                             !bitVol.GetBit(readLockToken, x - 1, y, z) || !bitVol.GetBit(readLockToken, x + 1, y, z) ||
                             !bitVol.GetBit(readLockToken, x, y - 1, z) || !bitVol.GetBit(readLockToken, x, y + 1, z)))
                        {
                            xcoords.Add(x);
                            ycoords.Add(y);
                        }
                    }
                }

                // check all pairs of the edge pixels
                int n = xcoords.Count;
                for (var i = 0; i < n; ++i)
                {
                    for (int j = i + 1; j < n; ++j)
                    {
                        double dx = (xcoords[i] - xcoords[j]) * xMM;
                        double dy = (ycoords[i] - ycoords[j]) * yMM;
                        double distSqr = (dx * dx) + (dy * dy);
                        if (distSqr >= maxAxialDistSqr)
                        {
                            if (onTumourDiameterCalculation)
                            {
                                InLineTumorDiameterLongDiamter(bitVol, ref maxAxialDistSqr, ref maxAxialDistZ, ref startx, ref starty, ref endx, ref endy, xcoords, ycoords, z, i, j, distSqr);
                            }
                            else
                            {
                                OutLineTumorDiameterLongDiamter(ref maxAxialDistSqr, ref maxAxialDistZ, ref startx, ref starty, ref endx, ref endy, xcoords, ycoords, z, i, j, distSqr);
                            }
                        }
                    }
                }
            }
        }

        maxSecondaryDiameter = Math.Sqrt(maxAxialDistSqr);
        indexMaxDiameterZ = maxAxialDistZ;
        if (indexMaxDiameterZ != -1)
        {
            maxSecondaryDiameterPos[0] = new Point3D(startx, starty, indexMaxDiameterZ);
            maxSecondaryDiameterPos[1] = new Point3D(endx, endy, indexMaxDiameterZ);
        }
        else
        {
            maxSecondaryDiameterPos[0] = new Point3D(minx, miny, minz);
            maxSecondaryDiameterPos[1] = new Point3D(minx, miny, minz);
        }

        // ================== calculate max. perpendicular diameter
        double curx = startx, cury = starty;
        double angle = Math.Atan2(endy - starty, endx - startx);
        double dir1 = angle - (Math.PI / 2);
        double dir2 = angle + (Math.PI / 2);
        double perStartx = startx;
        double perStarty = starty;
        double perEndx = startx;
        double perEndy = starty;

        var step = 0;
        double max_perpendicular_dist_square = 0;

        // move in direction of max diameter
        while ((Math.Abs(endx - curx) > 0 || Math.Abs(cury - endy) > 0) &&
               curx > minx - 5 && curx < maxx + 5 &&
               cury > miny - 5 && cury < maxy + 5)
        {
            // advance the currrent point by step
            curx = startx + (step * Math.Cos(angle));
            cury = starty + (step * Math.Sin(angle));

            // check if exceeds one of the max 2d diam. line edges
            if ((endx >= startx && curx > endx) || (endx < startx && curx < endx) ||
                (endy >= starty && cury > endy) || (endy < starty && cury < endy))
            {
                // set the current point to the end of the line
                curx = endx;
                cury = endy;
            }

            double pt1x = curx, pt1y = cury;
            double pt2x = curx, pt2y = cury;
            double maxpt1x = curx, maxpt1y = cury;
            double maxpt2x = curx, maxpt2y = cury;
            var steppt1 = 0;
            var steppt2 = 0;

            // move in perpendicular direction
            using (var readLockToken = bitVol.ReadLock())
            {
                while (
                pt1x > minx - 5 && pt1x < maxx + 5 &&
                pt1y > miny - 5 && pt1y < maxy + 5)
                {
                    pt1x = curx + (steppt1 * Math.Cos(dir1));
                    pt1y = cury + (steppt1 * Math.Sin(dir1));

                    if (bitVol.GetBit(readLockToken, (int)(pt1x + 0.5), (int)(pt1y + 0.5), maxAxialDistZ))
                    {
                        maxpt1x = pt1x;
                        maxpt1y = pt1y;
                    }

                    steppt1++;
                }
            }

            // opposite perpendicular direction
            using (var readLockToken = bitVol.ReadLock())
            {
                while (
                pt2x > minx - 5 && pt2x < maxx + 5 &&
                pt2y > miny - 5 && pt2y < maxy + 5)
                {
                    pt2x = curx + (steppt2 * Math.Cos(dir2));
                    pt2y = cury + (steppt2 * Math.Sin(dir2));

                    if (bitVol.GetBit(readLockToken, (int)(pt2x + 0.5), (int)(pt2y + 0.5), maxAxialDistZ))
                    {
                        maxpt2x = pt2x;
                        maxpt2y = pt2y;
                    }

                    steppt2++;
                }
            }

            double axialDx = (maxpt1x - maxpt2x) * xMM;
            double axialDy = (maxpt1y - maxpt2y) * yMM;
            double perpendicular_dist_square = (axialDx * axialDx) + (axialDy * axialDy);
            if (perpendicular_dist_square > max_perpendicular_dist_square)
            {
                if (onTumourDiameterCalculation) // Condition to get the selected Algorithm for calculating long diameter
                {
                    InLineTumorTrackingShortDiameter(bitVol, maxAxialDistZ, ref perStartx, ref perStarty, ref perEndx, ref perEndy, ref max_perpendicular_dist_square, maxpt1x, maxpt1y, maxpt2x, maxpt2y, perpendicular_dist_square);
                }
                else
                {
                    OutLineTumorTrackingShortDiameter(ref perStartx, ref perStarty, ref perEndx, ref perEndy, ref max_perpendicular_dist_square, maxpt1x, maxpt1y, maxpt2x, maxpt2y, perpendicular_dist_square);
                }
            }

            step++;
        }

        maxPerpendicularDiameter = Math.Sqrt(max_perpendicular_dist_square);

        if (indexMaxDiameterZ != -1)
        {
            maxPerpendicularDiameterPos[0] = new Point3D(perStartx, perStarty, indexMaxDiameterZ);
            maxPerpendicularDiameterPos[1] = new Point3D(perEndx, perEndy, indexMaxDiameterZ);
        }
        else
        {
            maxPerpendicularDiameterPos[0] = new Point3D(minx, miny, minz);
            maxPerpendicularDiameterPos[1] = new Point3D(minx, miny, minz);
        }

        if (maxPerpendicularDiameter > maxSecondaryDiameter)
        {
            maxPerpendicularDiameter = maxSecondaryDiameter;

            // switch??
        }

        // Sometimes with the maxDiameter calculation, it can be smaller than the maxSecondary diameter.
        // in this case it is advised to set the maxDiameter as the maxSecondary Diameter.
        if (maxDiameter < maxSecondaryDiameter)
        {
            maxDiameter = maxSecondaryDiameter;
        }
    }

#pragma warning restore PH2071

    private static void OutLineTumorDiameterLongDiamter(ref double maxAxialDistSqr, ref int maxAxialDistZ, ref int startx, ref int starty, ref int endx, ref int endy, List<int> xcoords, List<int> ycoords, int z, int i, int j, double distSqr)
    {
        maxAxialDistSqr = distSqr;
        maxAxialDistZ = z;
        startx = xcoords[i];
        starty = ycoords[i];
        endx = xcoords[j];
        endy = ycoords[j];
    }

    private static void InLineTumorDiameterLongDiamter(BitVol bitVol, ref double maxAxialDistSqr, ref int maxAxialDistZ, ref int startx, ref int starty, ref int endx, ref int endy, List<int> xcoords, List<int> ycoords, int z, int i, int j, double distSqr)
    {
        var isValidDiameter = true;
        double x1 = xcoords[i];
        double x2 = xcoords[j];
        double y1 = ycoords[i];
        double y2 = ycoords[j];
        if (xcoords[i] - xcoords[j] != 0)
        {
            double slope = (y1 - y2) / (x1 - x2);

            if (Math.Abs(slope) > 1) // walk along y and calculate corresponding x
            {
                var beginY = (int)Math.Min(y1, y2);
                var StopY = (int)Math.Max(y1, y2);
                double prevX = y1 < y2 ? x1 : x2;

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int yy = beginY + 3; yy < StopY - 3; yy++)
                    {
                        if (!bitVol.GetBit(readLockToken, (int)Math.Round(prevX + (1.0 / slope)), yy, z))
                        {
                            isValidDiameter = false;
                            continue;
                        }

                        prevX += 1.0 / slope;
                    }
                }
            }
            else if (slope != 0) // 0 < |slope| < 1, walk along x and calculate corresponding y
            {
                var beginX = (int)Math.Min(x1, x2);
                var StopX = (int)Math.Max(x1, x2);
                double prevY = x1 < x2 ? y1 : y2;

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int xx = beginX + 3; xx < StopX - 3; xx++)
                    {
                        if (!bitVol.GetBit(readLockToken, xx, (int)Math.Round(prevY + slope), z))
                        {
                            isValidDiameter = false;
                            break;
                        }

                        prevY += slope;
                    }
                }
            }
            else // slope = 0, walk along x only
            {
                var beginX = (int)Math.Min(x1, x2);
                var StopX = (int)Math.Max(x1, x2);

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int xx = beginX + 3; xx < StopX - 3; xx++)
                    {
                        if (!bitVol.GetBit(readLockToken, xx, (int)Math.Round(y1), z))
                        {
                            isValidDiameter = false;
                            break;
                        }
                    }
                }
            }
        }
        else // x coordinate is identical in both points: walk along y only
        {
            var beginY = (int)Math.Min(y1, y2);
            var StopY = (int)Math.Max(y1, y2);

            using (var readLockToken = bitVol.ReadLock())
            {
                for (int yy = beginY + 3; yy < StopY - 3; yy++)
                {
                    if (!bitVol.GetBit(readLockToken, (int)Math.Round(x1), yy, z))
                    {
                        isValidDiameter = false;
                        break;
                    }
                }
            }
        }

        if (isValidDiameter)
        {
            maxAxialDistSqr = distSqr;
            maxAxialDistZ = z;
            startx = xcoords[i];
            starty = ycoords[i];
            endx = xcoords[j];
            endy = ycoords[j];
        }
    }

    private static void OutLineTumorTrackingShortDiameter(ref double perStartx, ref double perStarty, ref double perEndx, ref double perEndy, ref double max_perpendicular_dist_square, double maxpt1x, double maxpt1y, double maxpt2x, double maxpt2y, double perpendicular_dist_square)
    {
        max_perpendicular_dist_square = perpendicular_dist_square;

        perStartx = maxpt1x;
        perStarty = maxpt1y;
        perEndx = maxpt2x;
        perEndy = maxpt2y;
    }

    private static void InLineTumorTrackingShortDiameter(BitVol bitVol, int maxAxialDistZ, ref double perStartx, ref double perStarty, ref double perEndx, ref double perEndy, ref double max_perpendicular_dist_square, double maxpt1x, double maxpt1y, double maxpt2x, double maxpt2y, double perpendicular_dist_square)
    {
        var nonTumorVoxels = 0;
        var totalTumourVoxels = 0;

        if (maxpt1x - maxpt2x != 0)
        {
            double slope = (maxpt1y - maxpt2y) / (maxpt1x - maxpt2x);

            if (Math.Abs(slope) > 1) // walk along y and calculate corresponding x
            {
                var beginY = (int)Math.Min(maxpt1y, maxpt2y);
                var StopY = (int)Math.Max(maxpt1y, maxpt2y);
                double prevX = maxpt1y > maxpt2y ? maxpt2x : maxpt1x;

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int yy = beginY + 3; yy < StopY - 3; yy++)
                    {
                        if (!bitVol.GetBit(readLockToken, (int)Math.Round(prevX + (1 / slope)), yy, maxAxialDistZ))
                        {
                            nonTumorVoxels++;

                            // break;
                        }

                        totalTumourVoxels++;
                        prevX += 1 / slope;
                    }
                }
            }
            else if (slope != 0) // 0 < |slope| < 1, walk along x and calculate corresponding y
            {
                var beginX = (int)Math.Min(maxpt1x, maxpt2x);
                var StopX = (int)Math.Max(maxpt1x, maxpt2x);
                double prevY = maxpt1x > maxpt2x ? maxpt2y : maxpt1y;

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int xx = beginX + 3; xx < StopX - 3; xx++)
                    {
                        if (!bitVol.GetBit(readLockToken, xx, (int)Math.Round(prevY + slope), maxAxialDistZ))
                        {
                            nonTumorVoxels++;

                            // break;
                        }

                        totalTumourVoxels++;
                        prevY += slope;
                    }
                }
            }
            else // slope = 0, walk along x only
            {
                var beginX = (int)Math.Min(maxpt1x, maxpt2x);
                var StopX = (int)Math.Max(maxpt1x, maxpt2x);

                using (var readLockToken = bitVol.ReadLock())
                {
                    for (int xx = beginX + 3; xx < StopX - 3; xx++)
                    {
                        if (!bitVol.GetBit(readLockToken, xx, (int)Math.Round(maxpt1y), maxAxialDistZ))
                        {
                            nonTumorVoxels++;

                            // break;
                        }

                        totalTumourVoxels++;
                    }
                }
            }
        }
        else // x coordinate is identical in both points: walk along y only
        {
            var beginY = (int)Math.Min(maxpt1y, maxpt2y);
            var StopY = (int)Math.Max(maxpt1y, maxpt2y);

            using (var readLockToken = bitVol.ReadLock())
            {
                for (int yy = beginY + 3; yy < StopY - 3; yy++)
                {
                    if (!bitVol.GetBit(readLockToken, (int)Math.Round(maxpt1x), yy, maxAxialDistZ))
                    {
                        nonTumorVoxels++;

                        // break;
                    }

                    totalTumourVoxels++;
                }
            }
        }

        if (totalTumourVoxels == 0 || nonTumorVoxels / (double)totalTumourVoxels < 0.1)
        {
            max_perpendicular_dist_square = perpendicular_dist_square;
            perStartx = maxpt1x;
            perStarty = maxpt1y;
            perEndx = maxpt2x;
            perEndy = maxpt2y;
        }
    }

    [SuppressMessage("Microsoft.Performance", "CA1809:AvoidExcessiveLocals")]
    [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
    private static unsafe int[] CalculatePercistPeakValue(IVolume volume, BitVol lesion, double sphereRadiusMM, out double peakValue)
    {
        if (lesion.ProvideBitsCount() == 0)
        {
            peakValue = 0;
            return null;
        }

        const int SUPER_SAMPLING = 4;

        // 1. build peak kernel
        double[] pixelSize =
            {
                volume.Geometry.XmmPerPixel, volume.Geometry.YmmPerPixel, volume.Geometry.ZmmPerPixel
            };

        var kx = (int)Math.Ceiling(sphereRadiusMM * 2 / pixelSize[0]);
        var ky = (int)Math.Ceiling(sphereRadiusMM * 2 / pixelSize[1]);
        var kz = (int)Math.Ceiling(sphereRadiusMM * 2 / pixelSize[2]);
        if (kx % 2 == 0)
        {
            kx++;
        }

        if (ky % 2 == 0)
        {
            ky++;
        }

        if (kz % 2 == 0)
        {
            kz++;
        }

        int kxh = kx / 2;
        int kyh = ky / 2;
        int kzh = kz / 2;

        var peakKernel = new double[kx * ky * kz];
        double sumWeights = 0;

        double px0 = kxh;
        double py0 = kyh;
        double pz0 = kzh;
        for (var k = 0; k < kz; ++k)
        {
            for (var j = 0; j < ky; ++j)
            {
                for (var i = 0; i < kx; ++i)
                {
                    var insideSphereCounter = 0;
                    for (var kk = 0; kk < SUPER_SAMPLING; ++kk)
                    {
                        for (var jj = 0; jj < SUPER_SAMPLING; ++jj)
                        {
                            for (var ii = 0; ii < SUPER_SAMPLING; ++ii)
                            {
                                // super-sampled point
                                double px = i - 0.5 + ((ii + 0.5) / SUPER_SAMPLING);
                                double py = j - 0.5 + ((jj + 0.5) / SUPER_SAMPLING);
                                double pz = k - 0.5 + ((kk + 0.5) / SUPER_SAMPLING);

                                // squared distance
                                double dsqr =
                                    ((px - px0) * (px - px0) * pixelSize[0] * pixelSize[0]) +
                                    ((py - py0) * (py - py0) * pixelSize[1] * pixelSize[1]) +
                                    ((pz - pz0) * (pz - pz0) * pixelSize[2] * pixelSize[2]);
                                if (dsqr <= sphereRadiusMM * sphereRadiusMM)
                                {
                                    insideSphereCounter++;
                                }
                            }
                        }
                    }

                    double w = insideSphereCounter / (double)(SUPER_SAMPLING * SUPER_SAMPLING * SUPER_SAMPLING);
                    peakKernel[(k * kx * ky) + (j * kx) + i] = w;
                    sumWeights += w;
                }
            }
        }

        if (sumWeights == 0)
        {
            peakValue = 0;
            return null;
        }

        // 2. calculate individual peak values for all relevant voxels and select largest individual peak value
        int vx = volume.Geometry.NumberOfVoxels.X;
        int vy = volume.Geometry.NumberOfVoxels.Y;
        int vz = volume.Geometry.NumberOfVoxels.Z;

        // lock slices
        var slices = new ushort*[vz];
        for (var z = 0; z < vz; ++z)
        {
            slices[z] = (ushort*)volume.Images[z].ImagePixels.Lock();
        }

        var maxp = new int[3];
        double maxIndividualPeakValue = 0;

        using (var readLockToken = lesion.ReadLock())
        {
            for (int z = kzh; z < vz - kzh; ++z)
            {
                for (int y = kyh; y < vy - kyh; ++y)
                {
                    for (int x = kxh; x < vx - kxh; ++x)
                    {
                        if (lesion.GetBit(readLockToken, x, y, z))
                        {
                            var voxelIsRelevant = true;
                            double sumWeightedValues = 0;
                            for (var k = 0; k < kz && voxelIsRelevant; ++k)
                            {
                                for (var j = 0; j < ky && voxelIsRelevant; ++j)
                                {
                                    for (var i = 0; i < kx && voxelIsRelevant; ++i)
                                    {
                                        int px = x + i - kxh;
                                        int py = y + j - kyh;
                                        int pz = z + k - kzh;
                                        double w = peakKernel[(k * kx * ky) + (j * kx) + i];
                                        if (w > 0 && !lesion.GetBit(readLockToken, px, py, pz))
                                        {
                                            voxelIsRelevant = false;
                                        }
                                        else
                                        {
                                            sumWeightedValues += w * slices[pz][(py * vx) + px];
                                        }
                                    }
                                }
                            }

                            if (voxelIsRelevant)
                            {
                                double individualPeakValue = sumWeightedValues / sumWeights;
                                if (individualPeakValue > maxIndividualPeakValue)
                                {
                                    maxIndividualPeakValue = individualPeakValue;
                                    maxp[0] = x;
                                    maxp[1] = y;
                                    maxp[2] = z;
                                }
                            }
                        }
                    }
                }
            }
        }

        // unlock slices
        for (var z = 0; z < vz; ++z)
        {
            volume.Images[z].ImagePixels.Unlock();
        }

        peakValue = maxIndividualPeakValue;
        return maxIndividualPeakValue == 0 ? null : maxp;
    }

    private static double GetVoxelVolume(VoxelBrick voxelBrick)
    {
        Size3I numberOfVoxels = voxelBrick.NumberOfVoxels;
        return (double)(voxelBrick.Brick.Volume / numberOfVoxels.X / numberOfVoxels.Y / numberOfVoxels.Z);
    }
}

}

in line 173 if (bitVol?.BitsCount > 0) , BitsCount should have been flaged and and instead a suggestion should have shown saying - use instead GetBitsCount(readLockToken)

Could you tell me a possible fix ? Will be really helpful thankyou .

CyrusNajmabadi · 2025-06-24T15:28:46Z

CyrusNajmabadi
Jun 24, 2025
Collaborator

Look at what x?.y is in a syntax visualizer. That will tell you what node kind you need to register an analysis callback for.

Alternatively, use IOperation callbacks, not syntax node callbacks.

1 reply

iram25484 Jun 24, 2025
Author

Thanks a lot . I found a solution , this analyser was not able to detect depricated member functions , it was only able to detect functions .

333fred · 2025-06-24T20:26:58Z

333fred
Jun 24, 2025
Maintainer

Why are you writing your own analyzer here, and not just using System.ObsoleteAttribute?

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Custom Analyzer not detecting deprecated property #79120

Uh oh!

{{title}}

Uh oh!

Replies: 2 comments 1 reply

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Custom Analyzer not detecting deprecated property #79120

Uh oh!

iram25484 Jun 24, 2025

What I'm trying to do

Here is the code for the analyser :

The Problem

Replies: 2 comments · 1 reply

Uh oh!

CyrusNajmabadi Jun 24, 2025 Collaborator

Uh oh!

iram25484 Jun 24, 2025 Author

Uh oh!

333fred Jun 24, 2025 Maintainer

iram25484
Jun 24, 2025

Replies: 2 comments 1 reply

CyrusNajmabadi
Jun 24, 2025
Collaborator

iram25484 Jun 24, 2025
Author

333fred
Jun 24, 2025
Maintainer