dotnet new classlib -n MyGenerator
cd MyGenerator
dotnet add package Microsoft.CodeAnalysis.CSharp
dotnet add package Microsoft.CodeAnalysis.Analyzers

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <IsRoslynComponent>true</IsRoslynComponent>
    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
  </ItemGroup>
</Project>

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;
using System.Text;

namespace MyGenerator;

[Generator]
public class HelloWorldGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context)
    {
        // Опціонально: реєстрація callbacks
    }

    public void Execute(GeneratorExecutionContext context)
    {
        // Генеруємо код
        string sourceCode = @"
namespace Generated
{
    public static class HelloWorld
    {
        public static string GetMessage() => ""Hello from Source Generator!"";
    }
}";

        context.AddSource("HelloWorld.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
    }
}

<ItemGroup>
  <ProjectReference Include="..\MyGenerator\MyGenerator.csproj"
                    OutputItemType="Analyzer"
                    ReferenceOutputAssembly="false" />
</ItemGroup>

using Generated;

Console.WriteLine(HelloWorld.GetMessage());
// Output: "Hello from Source Generator!"

using Microsoft.CodeAnalysis;

[Generator]
public class MyIncrementalGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // 1. Створити pipeline для аналізу коду
        var classDeclarations = context.SyntaxProvider
            .CreateSyntaxProvider(
                predicate: (node, _) => node is ClassDeclarationSyntax,
                transform: (ctx, _) => (ClassDeclarationSyntax)ctx.Node
            );

        // 2. Зареєструвати generation step
        context.RegisterSourceOutput(classDeclarations, Execute);
    }

    private void Execute(SourceProductionContext context, ClassDeclarationSyntax classDecl)
    {
        // 3. Генерувати код для кожного класу
        string className = classDecl.Identifier.Text;
        string code = $"// Generated for {className}";
        context.AddSource($"{className}.g.cs", code);
    }
}

namespace MyAttributes;

[AttributeUsage(AttributeTargets.Class)]
public class GenerateToStringAttribute : Attribute { }

using MyAttributes;

[GenerateToString]
public partial class User
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
}

// Згенерований код (User.ToString.g.cs):
// partial class User
// {
//     public override string ToString()
//     {
//         return $"User { Id = {Id}, Name = {Name} }";
//     }
// }

User user = new() { Id = 1, Name = "Alice" };
Console.WriteLine(user); // "User { Id = 1, Name = Alice }"

context.SyntaxProvider.ForAttributeWithMetadataName(
    fullyQualifiedMetadataName: "MyNamespace.MyAttribute",
    predicate: (node, _) => node is ClassDeclarationSyntax,
    transform: (ctx, ct) => /* ... */
);

var targetNodes = context.SyntaxProvider.CreateSyntaxProvider(
    predicate: (node, _) =>
    {
        // Фільтр на рівні синтаксису (швидко)
        return node is ClassDeclarationSyntax cls &&
               cls.AttributeLists.Count > 0;
    },
    transform: (ctx, _) =>
    {
        // Семантичний аналіз (повільно, але кешується)
        var classDecl = (ClassDeclarationSyntax)ctx.Node;
        var symbol = ctx.SemanticModel.GetDeclaredSymbol(classDecl);

        return symbol?.GetAttributes()
            .Any(a => a.AttributeClass?.Name == "MyAttribute") == true
            ? symbol
            : null;
    }
).Where(s => s is not null);

var sb = new StringBuilder();
sb.AppendLine("public class MyClass");
sb.AppendLine("{");
sb.AppendLine("    public int Id { get; set; }");
sb.AppendLine("}");

using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

ClassDeclarationSyntax classDecl = ClassDeclaration("MyClass")
    .AddModifiers(Token(SyntaxKind.PublicKeyword))
    .AddMembers(
        PropertyDeclaration(
            PredefinedType(Token(SyntaxKind.IntKeyword)),
            "Id"
        )
        .AddModifiers(Token(SyntaxKind.PublicKeyword))
        .AddAccessorListAccessors(
            AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
            AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
                .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
        )
    );

string code = classDecl.NormalizeWhitespace().ToFullString();

<PropertyGroup>
  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
  <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
</PropertyGroup>

public void Execute(...)
{
    if (!System.Diagnostics.Debugger.IsAttached)
    {
        System.Diagnostics.Debugger.Launch();
    }
    // ...
}

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Xunit;

public class GeneratorTests
{
    [Fact]
    public void GeneratesToString_ForMarkedClass()
    {
        string source = @"
using MyAttributes;

[GenerateToString]
public partial class User
{
    public string Name { get; set; }
}";

        var compilation = CreateCompilation(source);
        var generator = new ToStringGenerator();

        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
        driver = driver.RunGenerators(compilation);

        var result = driver.GetRunResult();

        Assert.Single(result.GeneratedTrees);
        Assert.Contains("public override string ToString()",
            result.GeneratedTrees[0].ToString());
    }

    private static Compilation CreateCompilation(string source)
    {
        var syntaxTree = CSharpSyntaxTree.ParseText(source);
        var references = AppDomain.CurrentDomain.GetAssemblies()
            .Where(a => !a.IsDynamic && !string.IsNullOrEmpty(a.Location))
            .Select(a => MetadataReference.CreateFromFile(a.Location));

        return CSharpCompilation.Create("TestAssembly",
            new[] { syntaxTree },
            references,
            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
    }
}

[GenerateEndpoint("/api/users", HttpMethod.Get)]
public static IResult GetUsers(IUserService service)
{
    return Results.Ok(service.GetAll());
}

// Генератор створює:
// app.MapGet("/api/users", GetUsers);

[GenerateMapper(typeof(UserDto))]
public partial class User
{
    public int Id { get; set; }
    public string Name { get; set; }

    // Генерується:
    // public UserDto ToDto() => new() { Id = this.Id, Name = this.Name };
}

[Service(ServiceLifetime.Scoped)]
public class UserRepository : IUserRepository
{
    // ...
}

// Генератор створює в статичному класі:
// services.AddScoped<IUserRepository, UserRepository>();

private void Execute(SourceProductionContext context, ClassInfo classInfo)
{
    if (!classInfo.IsPartial)
    {
        var diagnostic = Diagnostic.Create(
            new DiagnosticDescriptor(
                id: "GEN001",
                title: "Class must be partial",
                messageFormat: "Class '{0}' must be declared as partial",
                category: "Generator",
                DiagnosticSeverity.Error,
                isEnabledByDefault: true
            ),
            Location.None,
            classInfo.ClassName
        );

        context.ReportDiagnostic(diagnostic);
        return;
    }

    // Генерувати код...
}

[GenerateNotifyPropertyChanged]
public partial class ViewModel
{
    private string _name;
    // Генератор створить:
    // public string Name
    // {
    //     get => _name;
    //     set { _name = value; OnPropertyChanged(); }
    // }
}

[GenerateBuilder]
public partial class User
{
    public int Id { get; init; }
    public string Name { get; init; }
}

// Генерується UserBuilder:
// var user = new UserBuilder()
//     .WithId(1)
//     .WithName("Alice")
//     .Build();

public partial class RegisterDto
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    // Генерується метод:
    // public IEnumerable<ValidationError> Validate() { ... }
}