Migrate to IIncrementalSourceGenerator

src/Directory.Build.props

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

src/dotVariant.Generator.Test/GeneratorTools.cs

@@ -21,7 +21,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);
 
@@ -41,10 +41,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);
 
@@ -57,7 +57,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

@@ -22,12 +22,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 generator.RenderInfos.ToImmutableArray();
         }
     }
 }

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

@@ -6,13 +6,15 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="IsExternalInit" Version="1.0.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
-    <PackageReference Include="NUnit" Version="3.13.1" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
-    <PackageReference Include="System.Interactive" Version="5.0.0" />
-    <PackageReference Include="System.Reactive" Version="5.0.0" />
+    <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>

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/Descriptor.cs

@@ -10,7 +10,7 @@
 
 namespace dotVariant.Generator
 {
-    public sealed record Descriptor(
+    public readonly record struct Descriptor(
         INamedTypeSymbol Type,
         TypeDeclarationSyntax Syntax,
         ImmutableArray<IParameterSymbol> Options,
@@ -24,5 +24,12 @@ public static Descriptor FromDeclaration(
             var options = Inspect.GetOptions(type);
             return new(type, syntax, options, nullability);
         }
+
+        public string HintName => $"{Type.ToString()
+            // If the 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/DiagnosedResult.cs

@@ -0,0 +1,72 @@
+//
+// 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 any 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> : IEquatable<DiagnosedResult<TValue>>
+    where TValue: IEquatable<TValue>
+{
+    private readonly bool _noErrors;
+
+    public DiagnosedResult(ImmutableArray<Diagnostic> diagnostics, Func<TValue> valueFactory)
+    {
+        _noErrors = !diagnostics.Any(static d => d.Severity >= DiagnosticSeverity.Error);
+        Diagnostics = diagnostics;
+        ValueOrDefault = HasErrors ? default : valueFactory();
+    }
+
+    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)
+        where TResult : IEquatable<TResult>
+    {
+        var result = HasErrors ? default : selector(ValueOrDefault!);
+        return new DiagnosedResult<TResult>(Diagnostics, HasErrors, result);
+    }
+
+    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);
+        }
+    }
+}

src/dotVariant.Generator/Inspect.cs

@@ -64,11 +64,11 @@ public static bool IsAncestorOf(ITypeSymbol ancestor, ITypeSymbol type)
         public static Accessibility EffectiveAccessibility(ITypeSymbol type)
             => type.DeclaredAccessibility;
 
-        public static bool ImplementsDispose(ITypeSymbol type, CSharpCompilation compilation)
+        public static bool ImplementsDispose(ITypeSymbol type, INamedTypeSymbol disposableInterface)
         {
             var dispose =
                 FindMethod(
-                    compilation.GetTypeByMetadataName($"{nameof(System)}.{nameof(IDisposable)}")!,
+                    disposableInterface,
                     m => m.Name == nameof(IDisposable.Dispose));
             return type.FindImplementationForInterfaceMember(dispose!) is not null;
         }

src/dotVariant.Generator/RenderInfo.cs

@@ -24,7 +24,7 @@ namespace dotVariant.Generator
     /// <param name="Params">Properties of the parameters provided to <c>VariantOf</c>.</param>
     /// <param name="Runtime">Information about the .NET runtime we are generating code for.</param>
     /// <param name="Variant">Properties of the variant class.</param>
-    public sealed record RenderInfo(
+    public readonly record struct RenderInfo(
         RenderInfo.LanguageInfo Language,
         RenderInfo.OptionsInfo Options,
         ImmutableArray<RenderInfo.ParamInfo> Params,
@@ -37,15 +37,15 @@ public sealed record RenderInfo(
         /// <param name="Version">
         /// Integer of the form ABB where A=major and BB=minor version of the language (i.e. 703 -> 7.3)
         /// </param>
-        public sealed record LanguageInfo(
+        public readonly record struct LanguageInfo(
             string Nullable,
             int Version);
 
         /// <param name="ExtensionClassNamespace">
         /// The namespace in which to generate extension method implementations.
         /// If <see langword="null"/> use the global namespace.
         /// </param>
-        public sealed record OptionsInfo(
+        public readonly record struct OptionsInfo(
             string? ExtensionClassNamespace);
 
         /// <param name="HasHashCode">
@@ -54,7 +54,7 @@ public sealed record OptionsInfo(
         /// <param name="HasSystemReactiveLinq">
         /// <see langword="true"/> if <see cref="System.Reactive.Linq"/> namespace is found.
         /// </param>
-        public sealed record RuntimeInfo(
+        public readonly record struct RuntimeInfo(
             bool HasHashCode,
             bool HasSystemReactiveLinq);
 
@@ -102,7 +102,7 @@ public sealed record RuntimeInfo(
         /// <param name="UserDefined">
         /// Contains info about relevant members the user has defined.
         /// </param>
-        public sealed record VariantInfo(
+        public readonly record struct VariantInfo(
             string? Accessibility,
             bool CanBeNull,
             string DiagType,
@@ -121,7 +121,7 @@ public sealed record VariantInfo(
             /// <param name="Dispose">
             /// <see langword="true"/> if a user-defined <see cref="IDisposable.Dispose()"/> exists.
             /// </param>
-            public sealed record UserDefinitions(
+            public readonly record struct UserDefinitions(
                 bool Dispose);
 
             /// <param name="Constraints">
@@ -130,7 +130,7 @@ public sealed record UserDefinitions(
             /// <param name="Identifier">
             /// Identifier of the generic parameter.
             /// </param>
-            public sealed record GenericInfo(
+            public readonly record struct GenericInfo(
                 ImmutableArray<string> Constraints,
                 string Identifier);
         }
@@ -175,7 +175,7 @@ public sealed record GenericInfo(
         /// <param name="Type">
         /// The fully qualified name of the type including type parameter list, without nullability annotation.
         /// </param>
-        public sealed record ParamInfo(
+        public readonly record struct ParamInfo(
             bool CanBeNull,
             string DiagType,
             bool EmitImplicitCast,
@@ -192,14 +192,14 @@ public sealed record ParamInfo(
 
         public static RenderInfo FromDescriptor(
             Descriptor desc,
-            CSharpCompilation compilation,
+            CompilationInfo compilation,
             AnalyzerConfigOptionsProvider options,
             CancellationToken token)
         {
             var maxObjects = desc.Options.Max(NumReferenceFields);
             var type = desc.Type;
             var emitNullable = desc.NullableContext.HasFlag(NullableContext.AnnotationsEnabled);
-            var disposable = compilation.GetTypeByMetadataName(typeof(IDisposable).FullName)!;
+            var disposable = compilation.DisposableInterface;
 
             var paramDescriptors =
                 desc
@@ -229,8 +229,8 @@ public static RenderInfo FromDescriptor(
                     ExtensionClassNamespace: ExtensionsNamespace(options, typeNamespace)),
                 Params: paramDescriptors.ToImmutableArray(),
                 Runtime: new(
-                    HasHashCode: compilation.GetTypeByMetadataName("System.HashCode") is not null,
-                    HasSystemReactiveLinq: HasReactive(compilation)),
+                    HasHashCode: compilation.HasHashCode,
+                    HasSystemReactiveLinq: compilation.HasReactive),
                 Variant: new(
                     Accessibility: VariantAccessibility(type),
                     CanBeNull: type.IsReferenceType,
@@ -247,7 +247,7 @@ public static RenderInfo FromDescriptor(
                     Type: type.ToDisplayString(TopLevelTypeFormat),
                     UserDefined: new(
                         // If the user defined any method named Dispose() bail out. Too risky!
-                        Dispose: ImplementsDispose(type, compilation) || HasAnyDisposeMethod(type))));
+                        Dispose: ImplementsDispose(type, compilation.DisposableInterface) || HasAnyDisposeMethod(type))));
         }
 
         private static string DetermineOutType(IParameterSymbol p, bool emitNullable, LanguageVersion version)
@@ -351,9 +351,6 @@ private static int ConvertLanguageVersion(LanguageVersion v)
             return string.IsNullOrWhiteSpace(value) ? typeNamespace : value;
         }
 
-        private static bool HasReactive(CSharpCompilation compilation)
-            => compilation.GetTypeByMetadataName("System.Reactive.Linq.Observable") is not null;
-
         public static readonly SymbolDisplayFormat TopLevelTypeFormat = new(
             globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
             typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,