feat: add source generator for inline array attributes and refactor array structures (#7)

* feat: add source generator for inline array attributes and refactor array structures

* chore: update packages; replace FluentAssertions with AwesomeAssertions

* chore: add .NET 9 setup step to CI and release workflows

* fix: ensure that a zero length triggers diagnostic; correct syntax for AutoInlineArray attribute in tests

Author: volodymyr-fed

.github/workflows/ci.yaml

@@ -11,6 +11,10 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
+    - name: Setup .NET 9
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '9.0.x'
     - name: Checkout
       uses: actions/checkout@v4
     - name: Build

.github/workflows/release.yaml

@@ -9,6 +9,10 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
+    - name: Setup .NET 9
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '9.0.x'
     - name: Checkout
       uses: actions/checkout@v4
     - name: Verify commit exists in origin/master

.gitignore

@@ -360,4 +360,8 @@ MigrationBackup/
 .ionide/
 
 # Fody - auto-generated XML schema
-FodyWeavers.xsd
+FodyWeavers.xsd
+
+# Verify
+*.received.*
+*.received/

F1Game.UDP.Benchamrks/F1Game.UDP.Benchmarks.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.0" />
     <PackageReference Include="F1Sharp" Version="1.3.0" />
     <PackageReference Include="SimRacing.Telemetry.Receiver.F1.23" Version="1.0.1" />
   </ItemGroup>

F1Game.UDP.Benchamrks/ThirdPartyComparisonBenchmark.cs

@@ -83,7 +83,7 @@ static void SetupCarTelemetryPacket(byte[] data, Random random)
 			CarTelemetryData = packet.CarTelemetryData.AsEnumerable().Select(x => x with
 			{
 				Gear = random.GetItems(new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 1)[0],
-			}).ToArray22(),
+			}).ToArray(),
 			SuggestedGear = random.GetItems(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 1)[0]
 		};
 
@@ -99,7 +99,7 @@ static void SetupCarStatusPacket(byte[] data, Random random)
 			CarStatusData = packet.CarStatusData.AsEnumerable().Select(x => x with
 			{
 				VehicleFiaFlags = random.GetItems([FiaFlag.Green, FiaFlag.Yellow, FiaFlag.None, FiaFlag.Blue], 1)[0]
-			}).ToArray22()
+			}).ToArray()
 		};
 
 		var writer = new BytesWriter(data);
@@ -122,14 +122,14 @@ static void SetupSessionPacket(byte[] data, Random random)
 			MarshalZones = packet.MarshalZones.AsEnumerable().Select(x => x with
 			{
 				ZoneFlag = random.GetItems([FiaFlag.Green, FiaFlag.Yellow, FiaFlag.Blue, FiaFlag.None], 1)[0]
-			}).ToArray21(),
+			}).ToArray(),
 			WeatherForecastSamples = packet.WeatherForecastSamples.AsEnumerable().Select(x => x with
 			{
 				AirTemperature = (sbyte)random.Next(127),
 				TrackTemperature = (sbyte)random.Next(127),
 				AirTemperatureChange = (sbyte)random.Next(127),
 				TrackTemperatureChange = (sbyte)random.Next(127),
-			}).ToArray64()
+			}).ToArray()
 		};
 
 		var writer = new BytesWriter(data);

F1Game.UDP.SourceGenerator/AutoInlineArrayAttributeSource.cs

@@ -0,0 +1,66 @@
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis;
+using System.Text;
+
+namespace F1Game.UDP.SourceGenerator;
+
+static class AutoInlineArrayAttributeSource
+{
+	public const string FullyQualifiedAutoInlineArrayAttribute = $"{AutoInlineArrayAttributeNamespace}.{AutoInlineArrayAttributeFullName}";
+
+	const string AutoInlineArrayAttributeNamespace = "F1Game.UDP.SourceGenerator";
+	const string AutoInlineArrayAttributeFullName = "AutoInlineArrayAttribute";
+
+	const string SourceCode = $$"""
+		// <auto-generated/>
+		#nullable enable
+
+		using System;
+
+		namespace {{AutoInlineArrayAttributeNamespace}};
+
+		/// <summary>
+		/// Source Generator helper attribute. Apply to a partial struct definition
+		/// to generate an inline array implementation with the specified length.
+		/// The generator adds the <see cref="System.Runtime.CompilerServices.InlineArrayAttribute"/>,
+		/// implements <see cref="IEquatable{T}"/>, and provides common boilerplate code.
+		/// </summary>
+		/// <remarks>
+		/// <para>The struct must be declared as partial.</para>
+		/// <para>The first argument is the desired length (number of elements), must be greater than 0.</para>
+		/// <para>The second argument is type of instance field. Could be omitted if struct is generic or contains instance field.</para>
+		/// <para>
+		/// Field and Type Inference Rules:
+		/// <list type="number">
+		/// <item><description>If the partial struct does not contain an instance field, element type should be provided.</description></item>
+		/// <item><description>If the partial struct contains exactly one instance field (e.g., <c>private byte _element0;</c>), its type is used as the element type, and the generator DOES NOT add a field.</description></item>
+		/// <item><description>If the partial struct contains zero instance fields AND is generic (e.g., <c>partial struct MyArray&lt;T&gt;</c>), the first type parameter (<c>T</c>) is used as the element type, and the generator ADDS a field (e.g., <c>private T _element0;</c>).</description></item>
+		/// <item><description>If the partial struct contains zero instance fields AND is NOT generic, it's a compile-time error (element type cannot be inferred).</description></item>
+		/// <item><description>If the partial struct contains more than one instance field, it's a compile-time error.</description></item>
+		/// </list>
+		/// </para>
+		/// </remarks>
+		[AttributeUsage(AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
+		internal sealed class {{AutoInlineArrayAttributeFullName}} : Attribute
+		{
+			/// <summary>Initializes a new instance of the <see cref="{{AutoInlineArrayAttributeFullName}}"/> class.</summary>
+			/// <param name="length">The number of elements in the inline array. Must be greater than 0.</param>
+			public {{AutoInlineArrayAttributeFullName}}(int length, Type? elementType = null)
+			{
+				if (length <= 0)
+					throw new ArgumentOutOfRangeException(nameof(length), "Length must be greater than 0.");
+				Length = length;
+				ElementType = elementType;
+			}
+
+			/// <summary>Gets the number of elements intended for the inline array.</summary>
+			public int Length { get; }
+
+			/// <summary>Gets the type of the element in the inline array.</summary>
+			public Type? ElementType { get; init; } = null;
+		}
+		""";
+
+	public static void AddAttributeSource(IncrementalGeneratorPostInitializationContext context)
+		=> context.AddSource($"{FullyQualifiedAutoInlineArrayAttribute}.Generated.cs", SourceText.From(SourceCode, Encoding.UTF8));
+}

F1Game.UDP.SourceGenerator/AutoInlineArrayGenerator.cs

@@ -0,0 +1,248 @@
+using System.Text;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace F1Game.UDP.SourceGenerator;
+
+[Generator]
+sealed class AutoInlineArrayGenerator : IIncrementalGenerator
+{
+	public void Initialize(IncrementalGeneratorInitializationContext context)
+	{
+		context.RegisterPostInitializationOutput(AutoInlineArrayAttributeSource.AddAttributeSource);
+
+		IncrementalValuesProvider<BuildTarget> buildTargets = context.SyntaxProvider.ForAttributeWithMetadataName(
+				AutoInlineArrayAttributeSource.FullyQualifiedAutoInlineArrayAttribute,
+				predicate: static (node, _) => NodePredicate(node),
+				transform: static (ctx, ct) => GetSemanticTargetForGeneration(ctx, ct))
+			.Where(static m => m is not null)!;
+
+		context.RegisterSourceOutput(buildTargets, static (context, source) => ExecuteGeneration(context, source));
+	}
+
+	static bool NodePredicate(SyntaxNode node)
+	{
+		return node is TypeDeclarationSyntax { Keyword.RawKind: (int)SyntaxKind.StructKeyword }
+			|| node is RecordDeclarationSyntax { ClassOrStructKeyword.RawKind: (int)SyntaxKind.StructKeyword };
+	}
+
+	static BuildTarget? GetSemanticTargetForGeneration(GeneratorAttributeSyntaxContext context, CancellationToken _)
+	{
+		if (context.TargetSymbol is not INamedTypeSymbol type)
+			return null;
+
+		if (!type.DeclaringSyntaxReferences.Select(x => x.GetSyntax()).Any(x => x is TypeDeclarationSyntax typeSyntax && typeSyntax.Modifiers.Any(SyntaxKind.PartialKeyword)))
+			return Diagnostic.Create(DiagnosticDescriptors.TypeMustBePartial, type.Locations[0], type.Name);
+
+		if (context.Attributes.Length > 1)
+			return Diagnostic.Create(DiagnosticDescriptors.NoMoreThanOneAttribute, type.Locations[0], type.Name);
+
+		if (context.Attributes[0] is not { } attributeData)
+			return null;
+
+		if (attributeData.ConstructorArguments[0].Value is not int length || length <= 0)
+			return Diagnostic.Create(DiagnosticDescriptors.LengthShouldBePositiveNumber, type.Locations[0], type.Name);
+
+		var elementTypeFromAttribute = attributeData.ConstructorArguments.Length > 1
+			? attributeData.ConstructorArguments[1].Value as ITypeSymbol
+			: null;
+
+		var instanceFields = type.GetMembers()
+			.OfType<IFieldSymbol>()
+			.Where(f => !f.IsStatic && !f.IsConst)
+			.ToArray();
+
+		if (instanceFields.Length > 1)
+			return Diagnostic.Create(DiagnosticDescriptors.TooManyInstanceFields, type.Locations[0], type.Name);
+
+		return (instanceFields.FirstOrDefault(), elementTypeFromAttribute) switch
+		{
+			(null, null) when type.IsGenericType && type.TypeParameters.Length > 0 => new GenerationData(type, length, type.TypeParameters[0], true),
+			(null, { } elementType) => new GenerationData(type, length, elementType, true),
+			({ } field, null) => new GenerationData(type, length, field.Type, false),
+			({ }, { }) => Diagnostic.Create(DiagnosticDescriptors.InstanceFieldAndElementTypeArePresent, type.Locations[0], type.Name),
+			_ => Diagnostic.Create(DiagnosticDescriptors.NoTypeForInstanceField, type.Locations[0], type.Name),
+		};
+	}
+
+	static void ExecuteGeneration(SourceProductionContext context, BuildTarget target)
+	{
+		context.CancellationToken.ThrowIfCancellationRequested();
+
+		if (target.Diagnostic is not null)
+		{
+			context.ReportDiagnostic(target.Diagnostic);
+			return;
+		}
+
+		if (target.GenerationData is not GenerationData generationData)
+			return;
+
+		var (typeData, length, elementType, generateField) = generationData;
+		var (namespaceName, typeName, typeDeclaration, typeMetadataName) = typeData;
+		var namespaceDeclaration = namespaceName is null ? "" : $"namespace {namespaceName};";
+
+		string fieldGenerationCode = generateField
+			? $$"""
+					[SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Inline array element field must be mutable.")]
+					[SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "Field is used by the runtime for InlineArray layout and access.")]
+					private {{elementType}} _element0;
+				"""
+			: "";
+
+		string source = $$"""
+			// <auto-generated/>
+			#nullable enable
+
+			using System;
+			using System.Collections.Generic;
+			using System.Diagnostics.CodeAnalysis;
+			using System.Runtime.CompilerServices;
+
+			{{namespaceDeclaration}}
+
+			/// <summary>
+			/// Represents an inline array {{typeName}} with {{length}} elements of type <see cref="{{elementType}}"/>.
+			/// Provides basic equality comparison and hashing. Access elements using the indexer (e.g., myArray[0]).
+			/// </summary>
+			[InlineArray({{length}})]
+			partial {{typeDeclaration}} {{typeName}}
+				: IEquatable<{{typeName}}>
+			{
+			{{fieldGenerationCode}}
+
+				/// <summary>Gets the fixed length of the inline array: {{length}}.</summary>
+				public int Length => {{length}};
+
+				/// <summary>
+				/// Returns a <see cref="Span{T}"/> that represents the elements of this inline array.
+				/// </summary>
+				/// <returns>
+				/// A <see cref="Span{T}"/> of length <c>{{length}}</c> that provides mutable access to the elements of the inline array.
+				/// </returns>
+				public Span<{{elementType}}> AsSpan()
+					=> MemoryMarshal.CreateSpan(ref Unsafe.As<{{typeName}}, {{elementType}}>(ref this), {{length}});
+
+				/// <summary>
+				/// Returns a <see cref="ReadOnlySpan{T}"/> that represents the elements of this inline array.
+				/// </summary>
+				/// <returns>
+				/// A <see cref="ReadOnlySpan{T}"/> of length <c>{{length}}</c> that provides read-only access to the elements of the inline array.
+				/// </returns>
+				public ReadOnlySpan<{{elementType}}> AsReadOnlySpan()
+					=> MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<{{typeName}}, {{elementType}}>(ref this), {{length}});
+
+				/// <summary>
+				/// Returns an <see cref="IEnumerable{T}"/> that enumerates the elements of this inline array.
+				/// </summary>
+				/// <returns>
+				/// An <see cref="IEnumerable{T}"/> that iterates over the elements of the inline array in order.
+				/// </returns>
+				public IEnumerable<{{elementType}}> AsEnumerable()
+				{
+					foreach (var item in this)
+						yield return item;
+				}
+
+				/// <inheritdoc/>
+				public override bool Equals([NotNullWhen(true)] object? obj)
+					=> obj is {{typeName}} other && Equals(other);
+
+				/// <summary>Indicates whether the current inline array is equal to another inline array of the same type by comparing their elements sequentially.</summary>
+				/// <param name="other">An inline array to compare with this instance.</param>
+				/// <returns><c>true</c> if the current array's elements are equal to the <paramref name="other"/> array's elements; otherwise, <c>false</c>.</returns>
+				public bool Equals({{typeName}} other)
+					=> ((ReadOnlySpan<{{elementType}}>)this).SequenceEqual((ReadOnlySpan<{{elementType}}>)other);
+
+				/// <inheritdoc/>
+				public override int GetHashCode()
+				{
+					HashCode hashCode = default;
+					ReadOnlySpan<{{elementType}}> span = this;
+					var comparer = EqualityComparer<{{elementType}}>.Default;
+
+					foreach (ref readonly {{elementType}} item in span)
+						hashCode.Add(item, comparer);
+
+					return hashCode.ToHashCode();
+				}
+
+				/// <summary>
+				/// Creates a new <see cref="{{typeName}}"/> instance and populates it with elements from the specified <see cref="ReadOnlySpan{T}"/> source.
+				/// </summary>
+				/// <param name="source">
+				/// The sequence of elements to copy into the inline array. If the sequence contains fewer elements than the array's length, the remaining elements are left at their default value.
+				/// If the sequence contains more elements than the array's length, the extra elements are ignored.
+				/// </param>
+				/// <returns>
+				/// A new <see cref="{{typeName}}"/> instance containing elements from <paramref name="source"/>.
+				/// </returns>
+				public static {{typeName}} Create(ReadOnlySpan<{{elementType}}> source)
+				{
+					var array = new {{typeName}}();
+					for (var i = 0; i < array.Length && i < source.Length; i++)
+						array[i] = source[i];
+					return array;
+				}
+
+				/// <summary>Determines whether two specified instances of <see cref="{{typeName}}"/> are equal by comparing their elements sequence.</summary>
+				/// <param name="left">The first inline array to compare.</param>
+				/// <param name="right">The second inline array to compare.</param>
+				/// <returns><c>true</c> if the arrays are equal; otherwise, <c>false</c>.</returns>
+				public static bool operator ==({{typeName}} left, {{typeName}} right)
+					=> left.Equals(right);
+
+				/// <summary>Determines whether two specified instances of <see cref="{{typeName}}"/> are not equal by comparing their elements sequence.</summary>
+				/// <param name="left">The first inline array to compare.</param>
+				/// <param name="right">The second inline array to compare.</param>
+				/// <returns><c>true</c> if the arrays are not equal; otherwise, <c>false</c>.</returns>
+				public static bool operator !=({{typeName}} left, {{typeName}} right)
+					=> !(left == right);
+
+				/// <summary>
+				/// Implicitly converts an array of <see cref="{{elementType}}"/> to a <see cref="{{typeName}}"/>.
+				/// Copies up to <c>{{length}}</c> elements from the source array; extra elements are ignored, and missing elements are default-initialized.
+				/// </summary>
+				/// <param name="source">
+				/// The source array to copy elements from. If <paramref name="source"/> is <c>null</c>, a default-initialized <see cref="{{typeName}}"/> is returned.
+				/// </param>
+				/// <returns>
+				/// A <see cref="{{typeName}}"/> containing elements from <paramref name="source"/>.
+				/// </returns>
+				public static implicit operator {{typeName}}({{elementType}}[] source)
+					=> source is null ? new() : Create(source);
+
+				/// <summary>
+				/// Implicitly converts a <see cref="ReadOnlySpan{T}"/> of <see cref="{{elementType}}"/> to a <see cref="{{typeName}}"/>.
+				/// Copies up to <c>{{length}}</c> elements from the source span; extra elements are ignored, and missing elements are default-initialized.
+				/// </summary>
+				/// <param name="source">
+				/// The source span to copy elements from.
+				/// </param>
+				/// <returns>
+				/// A <see cref="{{typeName}}"/> containing elements from <paramref name="source"/>.
+				/// </returns>
+				public static implicit operator {{typeName}}(ReadOnlySpan<{{elementType}}> source)
+					=> Create(source);
+
+				/// <summary>
+				/// Implicitly converts a <see cref="Span{T}"/> of <see cref="{{elementType}}"/> to a <see cref="{{typeName}}"/>.
+				/// Copies up to <c>{{length}}</c> elements from the source span; extra elements are ignored, and missing elements are default-initialized.
+				/// </summary>
+				/// <param name="source">
+				/// The source span to copy elements from.
+				/// </param>
+				/// <returns>
+				/// A <see cref="{{typeName}}"/> containing elements from <paramref name="source"/>.
+				/// </returns>
+				public static implicit operator {{typeName}}(Span<{{elementType}}> source)
+					=> Create(source);
+			}
+			""";
+
+		context.AddSource($"{typeMetadataName}.Generated.cs", SourceText.From(source, Encoding.UTF8));
+	}
+}