Migrate to IIncrementalSourceGenerator

src/Directory.Build.props

@@ -21,7 +21,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeStyle" Version="4.6.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeStyle" Version="4.6.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
 </Project>

src/dotVariant.Generator.Function.Test/DiagnosedResultTest.cs

@@ -0,0 +1,59 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+using dotVariant.Generator;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace dotVariant.Generator.Function.Test;
+
+public sealed class DiagnosedResultTest
+{
+    [Test]
+    public void DefaultHasError()
+    {
+        DiagnosedResult<int> res = default;
+        Assert.That(res.HasErrors);
+    }
+
+    public static IEnumerable<object> ValueEmptyDiagnosticsNotHasErrorsSource => new object[] { 23, };
+
+    [Test, TestCaseSource(nameof(ValueEmptyDiagnosticsNotHasErrorsSource))]
+    public void ValueEmptyDiagnosticsNotHasErrors(object expectedValue)
+    {
+        DiagnosedResult<object> res = new(expectedValue);
+        Assert.That(!res.HasErrors);
+        Assert.That(res.TryGetValue(out var value));
+        Assert.That(value, Is.EqualTo(expectedValue));
+    }
+
+
+    private static Diagnostic CreateDummyDiagnostic(DiagnosticSeverity severity)
+    {
+        var severityName = severity.ToString();
+        return Diagnostic.Create(
+            new DiagnosticDescriptor("0", severityName, severityName, severityName, severity, true),
+            Location.Create("Test", new TextSpan(0, 1),
+                new LinePositionSpan(new LinePosition(0, 0), new LinePosition(0, 1))));
+    }
+
+    public static IEnumerable<Diagnostic> HasErrorDiagnosticsHasErrorsSource =>
+        Enum.GetValues<DiagnosticSeverity>().Select(CreateDummyDiagnostic).ToArray();
+
+    [Test, TestCaseSource(nameof(HasErrorDiagnosticsHasErrorsSource))]
+    public void ValueHasErrorDiagnosticsHasErrors(Diagnostic diagnostic)
+    {
+        var res = default(DiagnosedResult<object>).WithDiagnostics(ImmutableArray.Create(diagnostic));
+        var isSeverityError = diagnostic.Severity >= DiagnosticSeverity.Error;
+        Assert.That(res.HasErrors, Is.EqualTo(isSeverityError));
+        Assert.That(res.TryGetValue(out _), Is.EqualTo(!isSeverityError));
+    }
+}

src/dotVariant.Generator.Function.Test/dotVariant.Generator.Function.Test.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <LangVersion>11</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="IsExternalInit" Version="1.0.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.2" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="System.Interactive" Version="6.0.1" />
+    <PackageReference Include="System.Reactive" Version="6.0.0" />
+    <PackageReference Include="Verify.NUnit" Version="20.4.0" />
+    <PackageReference Include="Verify.SourceGenerators" Version="2.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\dotVariant.Generator\dotVariant.Generator.csproj" />
+  </ItemGroup>
+
+</Project>

src/dotVariant.Generator.Test/GeneratorTools.cs

@@ -19,7 +19,7 @@ namespace dotVariant.Generator.Test
 {
     internal static class GeneratorTools
     {
-        public static Dictionary<string, string> GetGeneratedOutput(IDictionary<string, string> sources, Func<ISourceGenerator> makeGenerator, bool failOnInvalidSource = false)
+        public static Dictionary<string, string> GetGeneratedOutput(IDictionary<string, string> sources, Func<IIncrementalGenerator> makeGenerator, bool failOnInvalidSource = false)
         {
             var compilation = Compile(sources);
 
@@ -39,10 +39,10 @@ public static Dictionary<string, string> GetGeneratedOutput(IDictionary<string,
         }
 
         public static Dictionary<string, string> GetGeneratedOutput<TGenerator>(IDictionary<string, string> sources, bool failOnInvalidSource = false)
-            where TGenerator : ISourceGenerator, new()
+            where TGenerator : IIncrementalGenerator, new()
             => GetGeneratedOutput(sources, () => new TGenerator(), failOnInvalidSource);
 
-        public static ImmutableArray<Diagnostic> GetGeneratorDiagnostics(IDictionary<string, string> sources, Func<ISourceGenerator> makeGenerator)
+        public static ImmutableArray<Diagnostic> GetGeneratorDiagnostics(IDictionary<string, string> sources, Func<IIncrementalGenerator> makeGenerator)
         {
             var compilation = Compile(sources);
 
@@ -55,7 +55,7 @@ public static ImmutableArray<Diagnostic> GetGeneratorDiagnostics(IDictionary<str
         }
 
         public static ImmutableArray<Diagnostic> GetGeneratorDiagnostics<TGenerator>(IDictionary<string, string> sources)
-            where TGenerator : ISourceGenerator, new()
+            where TGenerator : IIncrementalGenerator, new()
             => GetGeneratorDiagnostics(sources, () => new TGenerator());
 
         public static CSharpCompilation Compile(

src/dotVariant.Generator.Test/RenderInfo.cs

@@ -20,12 +20,11 @@ private static ImmutableArray<RenderInfo> GetRenderInfoFromCompilation(
         {
             var compilation = Compile(SupportSources.Add("input", source), version);
             var generator = new SourceGenerator();
-            var driver = CSharpGeneratorDriver.Create(
-                new[] { generator },
-                optionsProvider: new AnalyzerConfigOptionsProvider(msBuildProperties),
-                parseOptions: new CSharpParseOptions(version));
+            var driver = CSharpGeneratorDriver.Create(generator)
+                .WithUpdatedAnalyzerConfigOptions(new AnalyzerConfigOptionsProvider(msBuildProperties))
+                .WithUpdatedParseOptions(new CSharpParseOptions(version));
             _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out var _, out var _);
-            return generator.RenderInfos;
+            return DebugInfoCollector.TakeRenderInfoList().ToImmutableArray();
         }
     }
 }

src/dotVariant.Generator/CompilationInfo.cs

@@ -0,0 +1,23 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using System;
+
+namespace dotVariant.Generator;
+
+public readonly record struct CompilationInfo(LanguageVersion LanguageVersion, bool HasReactive,
+    INamedTypeSymbol DisposableInterface, bool HasHashCode)
+{
+    public static CompilationInfo FromCompilation(CSharpCompilation compilation)
+    {
+        var hasReactive = compilation.GetTypeByMetadataName("System.Reactive.Linq.Observable") is not null;
+        var disposableInterface = compilation.GetTypeByMetadataName(typeof(IDisposable).FullName)!;
+        var hasHashCode = compilation.GetTypeByMetadataName("System.HashCode") is not null;
+        return new(compilation.LanguageVersion, hasReactive, disposableInterface, hasHashCode);
+    }
+}

src/dotVariant.Generator/DebugInfoCollector.cs

@@ -0,0 +1,36 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+
+namespace dotVariant.Generator;
+
+public static class DebugInfoCollector
+{
+    private static readonly object _lock = new();
+    private static List<RenderInfo>? _renderInfos;
+
+    [Conditional("DEBUG")]
+    public static void AddRenderInfo(RenderInfo info)
+    {
+        lock (_lock)
+        {
+            var renderInfos = _renderInfos ??= new List<RenderInfo>();
+            renderInfos.Add(info);
+        }
+    }
+
+    public static List<RenderInfo> TakeRenderInfoList()
+    {
+        lock (_lock)
+        {
+            var list = Interlocked.Exchange(ref _renderInfos, null);
+            return list ?? new List<RenderInfo>();
+        }
+    }
+}

src/dotVariant.Generator/Descriptor.cs

@@ -8,19 +8,25 @@
 
 namespace dotVariant.Generator
 {
-    public sealed record Descriptor(
+    public readonly record struct Descriptor(
         INamedTypeSymbol Type,
         TypeDeclarationSyntax Syntax,
         ImmutableArray<IParameterSymbol> Options,
         NullableContext NullableContext)
     {
         public static Descriptor FromDeclaration(
-            INamedTypeSymbol type,
-            TypeDeclarationSyntax syntax,
+            SemanticType type,
             NullableContext nullability)
         {
-            var options = Inspect.GetOptions(type);
-            return new(type, syntax, options, nullability);
+            var options = Inspect.GetOptions(type.Symbol);
+            return new(type.Symbol, type.Syntax, options, nullability);
         }
+
+        public string HintName => $"{Type.ToString()
+            // If the type contains type parameters replace angle brackets as those are not allowed in AddSource()
+            .Replace('<', '{')
+            .Replace('>', '}')
+            // Escaped names like @class or @event aren't supported either
+            .Replace('@', '.')}.cs";
     }
 }

src/dotVariant.Generator/Diagnose.cs

@@ -15,11 +15,11 @@ namespace dotVariant.Generator
 {
     internal static class Diagnose
     {
-        public static IEnumerable<Diagnostic> Variant(ITypeSymbol type, TypeDeclarationSyntax syntax, CancellationToken token)
+        public static IEnumerable<Diagnostic> Variant(SemanticType type, CancellationToken token)
             => new[]
                 {
-                    CheckType(type, syntax, token),
-                    CheckOptions(type, token),
+                    CheckType(type.Symbol, type.Syntax, token),
+                    CheckOptions(type.Symbol, token),
                 }
                 .Concat();
 
@@ -155,14 +155,14 @@ public static IEnumerable<Diagnostic> NotTooManyOptions(
                 ImmutableArray<IParameterSymbol> options,
                 CancellationToken token)
             {
-                const int max = byte.MaxValue;
+                const int Max = byte.MaxValue;
 
-                if (options.Count() > max)
+                if (options.Count() > Max)
                 {
                     yield return MakeError(
                         nameof(NotTooManyOptions),
-                        $"'VariantOf()' must not have more than {max} parameters.",
-                        $"Variant types must not have more than {max} parameters in their 'VariantOf()' method.",
+                        $"'VariantOf()' must not have more than {Max} parameters.",
+                        $"Variant types must not have more than {Max} parameters in their 'VariantOf()' method.",
                         LocationOfFirstToken(syntax, SyntaxKind.IdentifierToken));
                 }
             }

src/dotVariant.Generator/DiagnosedResult.cs

@@ -0,0 +1,114 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+using Microsoft.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace dotVariant.Generator;
+
+/// <summary>A result type carrying <see cref="Diagnostic"/> values and a <typeparamref name="TValue"/> if and only if no errors are diagnosed.</summary>
+/// <typeparam name="TValue">The type of the value</typeparam>
+/// <remarks>Diagnosed result ignores diagnostics during equality comparison to improve caching consistency.</remarks>
+public readonly struct DiagnosedResult<TValue>
+{
+    private readonly bool _noErrors;
+
+    public DiagnosedResult(ImmutableArray<Diagnostic> diagnostics, TValue value)
+    {
+        _noErrors = !diagnostics.HasErrors();
+        Diagnostics = diagnostics;
+        ValueOrDefault = HasErrors ? default : value;
+    }
+
+    public DiagnosedResult(TValue value)
+    {
+        _noErrors = true;
+        Diagnostics = ImmutableArray<Diagnostic>.Empty;
+        ValueOrDefault = value;
+    }
+
+    private DiagnosedResult(ImmutableArray<Diagnostic> diagnostics, bool hasErrors, TValue? valueOrDefault)
+    {
+        _noErrors = !hasErrors;
+        Diagnostics = diagnostics;
+        ValueOrDefault = valueOrDefault;
+    }
+
+    public readonly ImmutableArray<Diagnostic> Diagnostics;
+    public readonly TValue? ValueOrDefault;
+
+    public bool HasErrors => !_noErrors;
+
+    public bool TryGetValue(out TValue value)
+    {
+        value = ValueOrDefault!;
+        return _noErrors;
+    }
+
+    public DiagnosedResult<TResult> Select<TResult>(Func<TValue, TResult> selector)
+    {
+        var result = HasErrors ? default : selector(ValueOrDefault!);
+        return new(Diagnostics, HasErrors, result);
+    }
+
+    public ImmutableArray<DiagnosedResult<TResult>> SelectMany<TResult>(Func<TValue, ImmutableArray<TResult>> selector)
+    {
+        var diagnostics = Diagnostics;
+        if (HasErrors)
+        {
+            // preserve diagnostics
+            return ImmutableArray.Create(new DiagnosedResult<TResult>(diagnostics, true, default!));
+        }
+
+        var results = selector(ValueOrDefault!);
+        return results.Select(r => new DiagnosedResult<TResult>(diagnostics, false, r)).ToImmutableArray();
+    }
+
+    public DiagnosedResult<TValue> WithDiagnostics(ImmutableArray<Diagnostic> diagnostics)
+    {
+        if (Diagnostics.IsDefaultOrEmpty && diagnostics.IsDefaultOrEmpty)
+        {
+            return new(ImmutableArray<Diagnostic>.Empty, HasErrors, ValueOrDefault);
+        }
+
+        diagnostics = Diagnostics.IsDefaultOrEmpty ? diagnostics : Diagnostics.AddRange(diagnostics);
+        return new(diagnostics, ValueOrDefault!);
+    }
+
+    public bool Equals(DiagnosedResult<TValue> other)
+    {
+        return HasErrors == other.HasErrors && EqualityComparer<TValue?>.Default.Equals(ValueOrDefault, other.ValueOrDefault);
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is DiagnosedResult<TValue> other && Equals(other);
+    }
+
+    public override int GetHashCode()
+    {
+        unchecked
+        {
+            return HasErrors ? 1337 : EqualityComparer<TValue?>.Default.GetHashCode(ValueOrDefault);
+        }
+    }
+}
+
+public static class DiagnosedResultExtensions
+{
+    public static DiagnosedResult<TValue> AsDiagnosedResult<TValue>(this TValue value)
+    {
+        return new(value);
+    }
+
+    public static bool HasErrors(this ImmutableArray<Diagnostic> diagnostics)
+    {
+        return diagnostics.Any(static d => d.Severity >= DiagnosticSeverity.Error);
+    }
+}