Unions2

CSharpSourceBuilder.TestApplication/Program.cs

@@ -1,8 +1,4 @@
 // See https://aka.ms/new-console-template for more information
 
 using RhoMicro.CodeAnalysis;
-using RhoMicro.CodeAnalysis.Lyra;
-
-using var builder = new CSharpSourceBuilder();
-
 

Janus.Analyzers/Components/JsonConverterComponent.cs

@@ -221,12 +221,7 @@ public override void Write(
                       {
                           ct.ThrowIfCancellationRequested();
 
-                          b.Append(
-                              $$"""
-                                global::System.Text.Json.JsonSerializer.Serialize(writer, value.CastTo{{v.Name}}, options);
-                                break;
-                                """
-                          );
+                          b.Append($"global::System.Text.Json.JsonSerializer.Serialize(writer, value.CastTo{v.Name}, options);");
                       }, static (_, b, ct) =>
                       {
                           ct.ThrowIfCancellationRequested();

Janus.Analyzers/Components/SwitchComponent.cs

@@ -66,6 +66,9 @@ public void Switch<TState>(
 
                               b.Append($"{typeof(Action)}<{v.Type.NullableName}, TState> on{v.Name}");
                           }, separator: ",\n")}})
+                      #if NET9_0_OR_GREATER
+                          where TState : allows ref struct
+                      #endif
                       {
                           {{new VariantsSwitchComponent(m, static (v, _, b, ct) =>
                           {
@@ -141,6 +144,9 @@ public void Switch<TState>(
 
                               b.Append($"{typeof(Action)}<{v.Type.NullableName}, TState>? on{v.Name} = null");
                           }, separator: ",\n")}})
+                      #if NET9_0_OR_GREATER
+                          where TState : allows ref struct
+                      #endif
                       {
                           {{new VariantsSwitchComponent(m, static (v, _, b, ct) =>
                           {
@@ -214,6 +220,9 @@ public TResult Switch<TState, TResult>(
 
                               b.Append($"{func}<{v.Type.NullableName}, TState, TResult> on{v.Name}");
                           }, separator: ",\n")}})
+                      #if NET9_0_OR_GREATER
+                          where TState : allows ref struct
+                      #endif
                       {
                           {{new VariantsSwitchComponent(m, static (v, _, b, ct) =>
                           {
@@ -287,6 +296,9 @@ public TResult Switch<TState, TResult>(
 
                               b.Append($"{func}<{v.Type.NullableName}, TState, TResult>? on{v.Name} = null");
                           }, separator: ",\n")}})
+                      #if NET9_0_OR_GREATER
+                          where TState : allows ref struct
+                      #endif
                       {
                           {{new VariantsSwitchComponent(m, static (v, _, b, ct) =>
                           {
@@ -370,6 +382,9 @@ public TResult Switch<TState, TResult>(
 
                               b.Append($"{func}<{v.Type.NullableName}, TState, TResult>? on{v.Name} = null");
                           }, separator: ",\n")}})
+                      #if NET9_0_OR_GREATER
+                          where TState : allows ref struct
+                      #endif
                       {
                           {{new VariantsSwitchComponent(m, static (v, _, b, ct) =>
                           {

Janus.Analyzers/Components/VariantsSwitchComponent.cs

@@ -14,6 +14,50 @@ public void AppendTo(CSharpSourceBuilder builder, CancellationToken cancellation
     {
         cancellationToken.ThrowIfCancellationRequested();
 
+        if (Model.Variants.Count < 24)
+        {
+            AppendIfElseStatements(builder, cancellationToken);
+        }
+        else
+        {
+            AppendSwitchStatement(builder, cancellationToken);
+        }
+    }
+
+    private void AppendIfElseStatements(CSharpSourceBuilder builder, CancellationToken cancellationToken)
+    {
+        foreach (var variant in Model.Variants)
+        {
+            builder.AppendLine($"if({VariantExpression} is VariantKind.{variant.Name})")
+                .AppendLine('{')
+                .Indent();
+
+            Append.Invoke(variant, Model, builder, cancellationToken);
+
+            builder.AppendLine()
+                .Detent()
+                .Append("} else ");
+        }
+
+        builder.AppendLine('{')
+            .Indent();
+
+        if (Default is not null)
+        {
+            Default.Invoke(Model, builder, cancellationToken);
+        }
+        else
+        {
+            builder.Append("throw CreateUnknownVariantException();");
+        }
+
+        builder.AppendLine()
+            .Detent()
+            .AppendLine('}');
+    }
+
+    private void AppendSwitchStatement(CSharpSourceBuilder builder, CancellationToken cancellationToken)
+    {
         builder.AppendLine($"switch({VariantExpression})")
             .AppendLine('{')
             .Indent();

Janus.Analyzers/Models/UnionTypeAttribute.Model.cs

@@ -11,7 +11,7 @@ partial class UnionTypeAttribute
     [StructLayout(LayoutKind.Auto)]
     partial record struct Model
     {
-        internal static readonly SymbolDisplayFormat TypeDisplayFormat = new SymbolDisplayFormat(
+        internal static readonly SymbolDisplayFormat TypeDisplayFormat = new(
             globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Included,
             typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
             genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
@@ -64,10 +64,21 @@ private void Initialize(ITypeParameterSymbol target, CancellationToken ct)
         [InitializationMethod(StateTypeName = "TypeArgumentState")]
         private void Initialize(ITypeSymbol variant, CancellationToken ct)
         {
-            var isInterface = variant.TypeKind is TypeKind.Interface;
-            var docsId = variant.GetDocumentationCommentId() ?? String.Empty;
+            var isArray = false;
 
-            if (variant is INamedTypeSymbol
+            var extractedVariant = variant;
+
+            if (variant is IArrayTypeSymbol { ElementType: { } elementType })
+            {
+                isArray = true;
+                extractedVariant = elementType;
+            }
+
+            var isInterface = extractedVariant.TypeKind is TypeKind.Interface;
+            var docsId = extractedVariant.GetDocumentationCommentId() ?? String.Empty;
+            var variantName = Name;
+
+            if (extractedVariant is INamedTypeSymbol
                 {
                     OriginalDefinition:
                     {
@@ -76,29 +87,37 @@ private void Initialize(ITypeSymbol variant, CancellationToken ct)
                     TypeArguments: [{ } actualVariant]
                 })
             {
-                Name ??= actualVariant.Name;
+                variantName ??= actualVariant.Name;
                 var name = actualVariant.ToDisplayString(TypeDisplayFormat);
                 Type = new(
-                    actualVariant.IsUnmanagedType ? VariantTypeKind.Unmanaged : VariantTypeKind.Value,
+                    isArray
+                        ? VariantTypeKind.Reference
+                        : actualVariant.IsUnmanagedType
+                            ? VariantTypeKind.Unmanaged
+                            : VariantTypeKind.Value,
                     IsNullable: true,
                     IsInterface: isInterface,
                     Name: name,
                     DocsId: docsId);
             }
             else
             {
-                Name ??= variant.Name;
+                variantName ??= extractedVariant.Name;
                 var name = variant.ToDisplayString(TypeDisplayFormat);
-                Type = variant switch
+                Type = extractedVariant switch
                 {
                     { IsUnmanagedType: true } =>
-                        new(VariantTypeKind.Unmanaged,
+                        new(isArray
+                                ? VariantTypeKind.Reference
+                                : VariantTypeKind.Unmanaged,
                             IsNullable: false,
                             IsInterface: isInterface,
                             Name: name,
                             DocsId: docsId),
                     { IsValueType: true } =>
-                        new(VariantTypeKind.Value,
+                        new(isArray
+                                ? VariantTypeKind.Reference
+                                : VariantTypeKind.Value,
                             IsNullable: false,
                             IsInterface: isInterface,
                             Name: name,
@@ -110,13 +129,19 @@ private void Initialize(ITypeSymbol variant, CancellationToken ct)
                             Name: name,
                             DocsId: docsId),
                     _ =>
-                        new(VariantTypeKind.Unknown,
+                        new(isArray
+                                ? VariantTypeKind.Reference
+                                : VariantTypeKind.Unknown,
                             IsNullable: false,
                             IsInterface: false,
                             Name: name,
                             DocsId: docsId),
                 };
             }
+
+            Name ??= isArray
+                ? $"{variantName}Array"
+                : variantName;
         }
 
         public VariantTypeModel Type { get; private set; }

Janus.Benchmarks/Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+  <PropertyGroup>
+    <NoWarn>$(NoWarn);CS1591</NoWarn>
+  </PropertyGroup>
+</Project>

Janus.Benchmarks/Janus.Benchmarks.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>preview</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>Janus.Benchmarks</AssemblyName>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.8"/>
+    <PackageReference Include="Dunet" Version="1.11.3" />
+    <PackageReference Include="RhoMicro.BdnLogging" Version="1.0.3" />
+    <PackageReference Include="OneOf" Version="3.0.271"/>
+    <PackageReference Include="OneOf.Extended" Version="3.0.271" />
+    <ProjectReference Include="..\Janus.Analyzers\Janus.Analyzers.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
+    <ProjectReference Include="..\Janus.CodeFixes\Janus.CodeFixes.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
+    <ProjectReference Include="..\Janus.Library\Janus.Library.csproj"/>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="BenchmarkDotNet.Artifacts\" />
+  </ItemGroup>
+
+</Project>

Janus.Benchmarks/MemoryOverlayingBenchmark.cs

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MPL-2.0
+
+using System.Reflection.Metadata;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using OneOf;
+using RhoMicro.CodeAnalysis;
+
+// Dunet doesn't emit the nested type as part of the hint name, and
+// so Roslyn doesn't emit its generated source when conflicting hint
+// names are used.
+// This is why the Dunet types are not modeled as nested types. 
+[Dunet.Union]
+public partial record MemoryOverlayingBenchmarkDunetUnion
+{
+    public partial record Int32(System.Int32 Value);
+
+    public partial record Single(System.Single Value);
+
+    public partial record Double(System.Double Value);
+
+    public partial record Int64(System.Int64 Value);
+}
+
+[SimpleJob, MemoryDiagnoser]
+public partial class MemoryOverlayingBenchmark
+{
+    public class ClassOneOfUnion : OneOfBase<Int32, Single, Double, Int64>
+    {
+        public ClassOneOfUnion(OneOf<Int32, Single, Double, Int64> input) : base(input)
+        {
+        }
+    }
+
+    [UnionType<Int32, Single, Double, Int64>]
+    public sealed partial class ClassJanusUnion;
+
+    [UnionType<Int32, Single, Double, Int64>]
+    public readonly partial struct StructJanusUnion;
+
+    [Benchmark]
+    public StructJanusUnion StructJanusUnionAllocations() => new(GetValue());
+
+    [Benchmark(Baseline = true)]
+    public ClassJanusUnion ClassJanusUnionAllocations() => new(GetValue());
+
+    [Benchmark]
+    public ClassOneOfUnion ClassOneOfUnionAllocations() => new(GetValue());
+
+    [Benchmark]
+    public OneOf<Int32, Single, Double, Int64> StructOneOfUnionAllocations()
+        => GetValue(); // OneOf does not publish a ctor
+
+    [Benchmark]
+    public MemoryOverlayingBenchmarkDunetUnion DunetUnionAllocations()
+        => new MemoryOverlayingBenchmarkDunetUnion.Int32(GetValue());
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static Int32 GetValue() => 0;
+}