AutoDisposeSourceGenerator.cs

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Platform.Disposables.SourceGenerator
{
    [Generator]
    public class AutoDisposeSourceGenerator : ISourceGenerator
    {
        public void Initialize(GeneratorInitializationContext context)
        {
            context.RegisterForSyntaxNotifications(() => new ClassSyntaxReceiver());
        }

        public void Execute(GeneratorExecutionContext context)
        {
            if (!(context.SyntaxReceiver is ClassSyntaxReceiver receiver))
                return;

            foreach (var classDeclaration in receiver.CandidateClasses)
            {
                var semanticModel = context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree);
                var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration);

                if (classSymbol == null)
                    continue;

                if (!InheritsFromDisposableBase(classSymbol))
                    continue;

                if (HasAutoDisposeAttribute(classSymbol))
                {
                    var sourceCode = GenerateDisposeMethod(classSymbol, classDeclaration);
                    if (!string.IsNullOrEmpty(sourceCode))
                    {
                        context.AddSource($"{classSymbol.Name}.AutoDispose.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
                    }
                }
            }
        }

        private bool InheritsFromDisposableBase(INamedTypeSymbol classSymbol)
        {
            var baseType = classSymbol.BaseType;
            while (baseType != null)
            {
                if (baseType.Name == "DisposableBase" && 
                    baseType.ContainingNamespace?.ToDisplayString() == "Platform.Disposables")
                {
                    return true;
                }
                baseType = baseType.BaseType;
            }
            return false;
        }

        private bool HasAutoDisposeAttribute(INamedTypeSymbol classSymbol)
        {
            return classSymbol.GetAttributes().Any(a => 
                a.AttributeClass?.Name == "AutoDisposeAttribute" ||
                a.AttributeClass?.Name == "AutoDispose");
        }

        private string GenerateDisposeMethod(INamedTypeSymbol classSymbol, ClassDeclarationSyntax classDeclaration)
        {
            var disposableFields = GetDisposableFields(classSymbol);
            if (!disposableFields.Any())
                return string.Empty;

            var namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
            var className = classSymbol.Name;

            var disposeStatements = GenerateDisposeStatements(disposableFields);

            var sourceCode = $@"// <auto-generated />
#nullable enable
using System;

namespace {namespaceName}
{{
    partial class {className}
    {{
        protected override void Dispose(bool manual, bool wasDisposed)
        {{
            if (!wasDisposed)
            {{
{disposeStatements}
            }}
        }}
    }}
}}";

            return sourceCode;
        }

        private List<IFieldSymbol> GetDisposableFields(INamedTypeSymbol classSymbol)
        {
            var disposableFields = new List<IFieldSymbol>();

            foreach (var member in classSymbol.GetMembers())
            {
                if (member is IFieldSymbol field)
                {
                    if (IsDisposableType(field.Type))
                    {
                        disposableFields.Add(field);
                    }
                }
            }

            return disposableFields;
        }

        private bool IsDisposableType(ITypeSymbol typeSymbol)
        {
            // Check for System.IDisposable
            if (ImplementsInterface(typeSymbol, "System", "IDisposable"))
                return true;

            // Check for Platform.Disposables.IDisposable
            if (ImplementsInterface(typeSymbol, "Platform.Disposables", "IDisposable"))
                return true;

            return false;
        }

        private bool ImplementsInterface(ITypeSymbol typeSymbol, string namespaceName, string interfaceName)
        {
            return typeSymbol.AllInterfaces.Any(i => 
                i.Name == interfaceName && 
                i.ContainingNamespace?.ToDisplayString() == namespaceName);
        }

        private string GenerateDisposeStatements(List<IFieldSymbol> disposableFields)
        {
            var statements = new StringBuilder();

            foreach (var field in disposableFields)
            {
                statements.AppendLine($"                {field.Name}?.Dispose();");
                // Only set to null if field is not readonly
                if (field.Type.CanBeReferencedByName && !field.IsReadOnly)
                {
                    statements.AppendLine($"                {field.Name} = null;");
                }
            }

            return statements.ToString().TrimEnd();
        }
    }

    internal class ClassSyntaxReceiver : ISyntaxReceiver
    {
        public List<ClassDeclarationSyntax> CandidateClasses { get; } = new();

        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
        {
            if (syntaxNode is ClassDeclarationSyntax classDeclaration)
            {
                // Look for classes that might need auto-dispose generation
                if (classDeclaration.AttributeLists.Any() || 
                    classDeclaration.BaseList?.Types.Any() == true)
                {
                    CandidateClasses.Add(classDeclaration);
                }
            }
        }
    }
}