Following Fildor's advice I decided to implement a source generator to solve this issue. I've never implemented one before, so I'm open to feedback on how to improve this code. Specifically, if anyone has a working example of how to ensure that the ImmutableArray<> class is indeed the System.Collections.Immutable variant I'd be interested.
This code should account for edge cases such as the record being nested within interfaces/classes/records, the record being generic, the ImmutableArrays being nullable, custom Equals/GetHashCode methods already existing, etc.
I decided against locating the records via an attribute, as I want this to be the default behaviour for all of my libraries. I also have the partial check disabled in my codebase, as I want to be notified when I've created a record that has an ImmutableArray property/field and no override of the equals check, as I feel the lack of sequence equality is 'surprising' behaviour despite being the .NET default.
I've also added a custom attribute Key to decorate properties/fields when a subset of fields should uniquely identify the record. This allows for GetHashCode to be more performant by excluding other fields.
Here is the code for the source generator:
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using System.Threading;
namespace SourceGenerator;
[Generator(LanguageNames.CSharp)]
public sealed class RecordEqualityGenerator : IIncrementalGenerator {
private sealed record Field {
internal Field(string name, bool isImmutableArray, bool isKey) {
Name = name;
IsImmutableArray = isImmutableArray;
IsKey = isKey;
}
internal string Name { get; }
internal bool IsImmutableArray { get; }
internal bool IsKey { get; }
}
public void Initialize(IncrementalGeneratorInitializationContext context) {
var provider = context.SyntaxProvider.CreateSyntaxProvider(Predicate, Transform);
context.RegisterSourceOutput(provider, Execute);
}
private static bool Predicate(SyntaxNode node, CancellationToken _) {
if (node is not RecordDeclarationSyntax record)
return false;
if (!record.Modifiers.Any(m => m.Text == "partial"))
return false;
var hasImmutableArray = false;
var hasEquals = false;
var hasGetHashCode = false;
foreach (var member in record.Members) {
if (IsImmutableArrayPropertyOrField(member))
hasImmutableArray = true;
if (IsEqualsMethod(member, record))
hasEquals = true;
if (IsGetHashCodeMethod(member))
hasGetHashCode = true;
}
return hasImmutableArray && (!hasEquals || !hasGetHashCode);
}
private static RecordDeclarationSyntax Transform(GeneratorSyntaxContext ctx, CancellationToken _) => (RecordDeclarationSyntax)ctx.Node;
private static void Execute(SourceProductionContext context, RecordDeclarationSyntax record) {
const string Indent = " ";
var (hasEquals, hasGetHashCode) = HasEqualsAndGetHashCodeMethods(record);
var recordName = GetNameWithGenericParameters(record);
var scopes = GetScopes(record);
var fields = GetPropertyAndFieldNames(record);
var hashes = GetHashes(fields);
var filename = GetFilename(record);
var codeBuilder = new StringBuilder()
.AppendLine("using SourceGenerator;")
.AppendLine("using System.Linq;")
.AppendLine();
var indent = string.Empty;
foreach (var scope in scopes) {
_ = codeBuilder.AppendLine($"{indent}{scope}");
if (scope.Last() == '{')
indent += Indent;
}
if (!hasEquals) {
if (fields.Length == 1) {
_ = codeBuilder.AppendLine($"{indent}public bool Equals({recordName}? other) => other?.{fields[0].Name}.SequenceEqual({fields[0].Name}) ?? false;");
}
else {
var equalityText = GetEqualityText(fields);
_ = codeBuilder
.AppendLine($"{indent}public bool Equals({recordName}? other) {{")
.AppendLine($"{indent} if (other == null)")
.AppendLine($"{indent} return false;")
.AppendLine($"{indent} if (ReferenceEquals(this, other))")
.AppendLine($"{indent} return true;")
.AppendLine()
.AppendLine($"{indent} return {equalityText};")
.AppendLine($"{indent}}}");
}
if (!hasGetHashCode)
_ = codeBuilder.AppendLine();
}
if (!hasGetHashCode) {
if (hashes.Length == 1) {
_ = codeBuilder.AppendLine($"{indent}public override int GetHashCode() => {hashes[0]};");
}
else {
_ = codeBuilder
.AppendLine($"{indent}public override int GetHashCode() {{")
.AppendLine($"{indent} const int mod = 92821;")
.AppendLine($"{indent} var hash = 17;")
.AppendLine()
.AppendLine($"{indent} unchecked {{");
foreach (var hash in hashes)
_ = codeBuilder.AppendLine($"{indent} hash = hash * mod + {hash};");
_ = codeBuilder
.AppendLine($"{indent} }}")
.AppendLine()
.AppendLine($"{indent} return hash;")
.AppendLine($"{indent}}}");
}
}
foreach (var scope in scopes) {
if (scope.Last() != '{')
continue;
indent = indent.Substring(0, indent.Length - Indent.Length);
_ = codeBuilder.AppendLine($"{indent}}}");
}
context.AddSource(filename, codeBuilder.ToString());
}
private static (bool HasEquals, bool HasGetHashCode) HasEqualsAndGetHashCodeMethods(RecordDeclarationSyntax record) {
var hasEquals = false;
var hasGetHashCode = false;
foreach (var member in record.Members) {
if (member is not MethodDeclarationSyntax method)
continue;
switch (method.Identifier.Text) {
case "Equals":
if (IsEqualsMethod(method, record))
hasEquals = true;
break;
case "GetHashCode":
if (IsGetHashCodeMethod(method))
hasGetHashCode = true;
break;
default:
break;
}
}
return (hasEquals, hasGetHashCode);
}
private static bool IsEqualsMethod(MemberDeclarationSyntax member, RecordDeclarationSyntax record) {
if (member is not MethodDeclarationSyntax method)
return false;
if (method.Identifier.Text != "Equals")
return false;
if (!method.Modifiers.Any(m => m.Text == "public"))
return false;
if (method.Modifiers.Any(m => m.Text == "static"))
return false;
if (method.ReturnType is not PredefinedTypeSyntax returnType)
return false;
if (returnType.Keyword.Text != "bool")
return false;
if (method.ParameterList.Parameters.Count != 1)
return false;
if (method.ParameterList.Parameters[0].Type is not NullableTypeSyntax nullableParameter)
return false;
if (record.TypeParameterList?.Parameters.Any() ?? false) {
if (nullableParameter.ElementType is not GenericNameSyntax genericName)
return false;
if (genericName.Identifier.Text != record.Identifier.Text)
return false;
if (genericName.TypeArgumentList.Arguments.Count != record.TypeParameterList.Parameters.Count)
return false;
if (!genericName.TypeArgumentList.Arguments.All(a => a is IdentifierNameSyntax))
return false;
if (!genericName.TypeArgumentList.Arguments.Cast<IdentifierNameSyntax>().Select(a => a.Identifier.Text).SequenceEqual(record.TypeParameterList.Parameters.Select(p => p.Identifier.Text)))
return false;
return true;
}
if (nullableParameter.ElementType is not IdentifierNameSyntax identifierName)
return false;
if (identifierName.Identifier.Text != record.Identifier.Text)
return false;
return true;
}
private static bool IsGetHashCodeMethod(MemberDeclarationSyntax member) {
if (member is not MethodDeclarationSyntax method)
return false;
if (method.Identifier.Text != "GetHashCode")
return false;
if (!method.Modifiers.Any(m => m.Text == "public"))
return false;
if (!method.Modifiers.Any(m => m.Text == "override"))
return false;
return true;
}
private static ImmutableArray<string> GetScopes(RecordDeclarationSyntax record) {
return Get(record).Reverse().ToImmutableArray();
static IEnumerable<string> Get(RecordDeclarationSyntax record) {
for (SyntaxNode? current = record; current != null; current = current.Parent) {
var scope = current switch {
FileScopedNamespaceDeclarationSyntax node => $"namespace {node.Name};\r\n",
NamespaceDeclarationSyntax node => $"namespace {node.Name} {{",
RecordDeclarationSyntax node => $"{GetModifierPrefix(node)}record {GetNameWithGenericParameters(node)} {{",
ClassDeclarationSyntax node => $"{GetModifierPrefix(node)}class {GetNameWithGenericParameters(node)} {{",
InterfaceDeclarationSyntax node => $"{GetModifierPrefix(node)}interface {GetNameWithGenericParameters(node)} {{",
_ => null
};
if (scope != null)
yield return scope;
}
}
}
private static string GetNameWithGenericParameters(TypeDeclarationSyntax type) {
if (type.TypeParameterList == null || !type.TypeParameterList.Parameters.Any())
return type.Identifier.Text;
var parameters = type.TypeParameterList.Parameters.Select(p => p.Identifier.Text);
var parametersText = string.Join(", ", parameters);
return $"{type.Identifier.Text}<{parametersText}>";
}
private static string GetModifierPrefix(TypeDeclarationSyntax type) {
var builder = new StringBuilder();
foreach (var modifier in type.Modifiers)
_ = builder.Append($"{modifier} ");
return builder.ToString();
}
private static ImmutableArray<Field> GetPropertyAndFieldNames(RecordDeclarationSyntax record) {
var fields = ImmutableArray.CreateBuilder<Field>();
foreach (var member in record.Members) {
if (member is PropertyDeclarationSyntax property) {
var isImmutableArray = IsImmutableArrayProperty(property);
var isKey = property.AttributeLists.SelectMany(l => l.Attributes).Any(a => a.Name is IdentifierNameSyntax name && name.Identifier.Text == "Key");
fields.Add(new(property.Identifier.Text, isImmutableArray, isKey));
}
else if (member is FieldDeclarationSyntax field) {
var isImmutableArray = IsImmutableArrayField(field);
var isKey = field.AttributeLists.SelectMany(l => l.Attributes).Any(a => a.Name is IdentifierNameSyntax name && name.Identifier.Text == "Key");
foreach (var variable in field.Declaration.Variables)
fields.Add(new(variable.Identifier.Text, isImmutableArray, isKey));
}
}
return fields.ToImmutable();
}
private static bool IsImmutableArrayPropertyOrField(MemberDeclarationSyntax member) {
if (member is PropertyDeclarationSyntax property)
return IsImmutableArrayProperty(property);
if (member is FieldDeclarationSyntax field)
return IsImmutableArrayField(field);
return false;
}
private static bool IsImmutableArrayProperty(PropertyDeclarationSyntax property) {
if (property.Type is GenericNameSyntax generic) {
if (generic.Identifier.Text != "ImmutableArray")
return false;
if (generic.TypeArgumentList.Arguments.Count != 1)
return false;
return true;
}
if (property.Type is not NullableTypeSyntax nullable)
return false;
if (nullable.ElementType is not GenericNameSyntax nullableGeneric)
return false;
if (nullableGeneric.Identifier.Text != "ImmutableArray")
return false;
if (nullableGeneric.TypeArgumentList.Arguments.Count != 1)
return false;
return true;
}
private static bool IsImmutableArrayField(FieldDeclarationSyntax field) {
if (field.Declaration.Type is GenericNameSyntax generic) {
if (generic.Identifier.Text != "ImmutableArray")
return false;
if (generic.TypeArgumentList.Arguments.Count != 1)
return false;
return true;
}
if (field.Declaration.Type is not NullableTypeSyntax nullable)
return false;
if (nullable.ElementType is not GenericNameSyntax nullableGeneric)
return false;
if (nullableGeneric.Identifier.Text != "ImmutableArray")
return false;
if (nullableGeneric.TypeArgumentList.Arguments.Count != 1)
return false;
return true;
}
private static string GetEqualityText(ImmutableArray<Field> fields) {
var builder = new StringBuilder();
var isFirst = true;
foreach (var field in fields.Where(f => !f.IsImmutableArray)) {
if (!isFirst)
_ = builder.Append(" && ");
_ = builder.Append($"{field.Name} == other.{field.Name}");
isFirst = false;
}
foreach (var field in fields.Where(f => f.IsImmutableArray)) {
if (!isFirst)
_ = builder.Append(" && ");
_ = builder.Append($"{field.Name}.SequenceEqual(other.{field.Name})");
isFirst = false;
}
return builder.ToString();
}
private static ImmutableArray<string> GetHashes(ImmutableArray<Field> fields) {
var keys = fields.Where(f => f.IsKey).ToImmutableArray();
if (!keys.IsEmpty)
fields = keys;
var hashes = ImmutableArray.CreateBuilder<string>(fields.Length);
foreach (var field in fields.Where(f => !f.IsImmutableArray))
hashes.Add($"{field.Name}.GetHashCode()");
foreach (var field in fields.Where(f => f.IsImmutableArray))
hashes.Add($"{field.Name}.GenerateSequenceHashCode()");
return hashes.MoveToImmutable();
}
private static string GetFilename(RecordDeclarationSyntax record) {
var parts = GetParts(record).Reverse();
var stem = string.Join(".", parts);
return $"{stem}.g.cs";
static IEnumerable<string> GetParts(RecordDeclarationSyntax record) {
for (SyntaxNode? current = record; current != null; current = current.Parent) {
var scope = current switch {
FileScopedNamespaceDeclarationSyntax node => node.Name.ToString(),
NamespaceDeclarationSyntax node => node.Name.ToString(),
RecordDeclarationSyntax node => GetFilenamePartWithGenericParameters(node),
ClassDeclarationSyntax node => GetFilenamePartWithGenericParameters(node),
InterfaceDeclarationSyntax node => GetFilenamePartWithGenericParameters(node),
_ => null
};
if (scope != null)
yield return scope;
}
}
}
private static string GetFilenamePartWithGenericParameters(TypeDeclarationSyntax type) {
if (type.TypeParameterList == null || !type.TypeParameterList.Parameters.Any())
return type.Identifier.Text;
var parameters = type.TypeParameterList.Parameters.Select(p => p.Identifier.Text);
var parametersText = string.Join(", ", parameters);
return $"{type.Identifier.Text}[{parametersText}]";
}
}
This is an attribute I implemented that enables for more efficient GetHashCode generation when a subset of fields should uniquely identify the record:
using System;
namespace SourceGenerator;
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
public sealed class KeyAttribute : Attribute { }
And these are the extension methods for generating a hash code for an ImmutableArray based off the elements it contains, and for wrappering sequence equality on nullable ImmutableArrays:
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
namespace SourceGenerator;
public static class Extensions {
public static bool SequenceEqual<T>(this Nullable<ImmutableArray<T>> self, Nullable<ImmutableArray<T>> other, IEqualityComparer<T>? comparer = null) {
if (self == null)
return other == null;
if (other == null)
return false;
return self.Value.SequenceEqual(other.Value, comparer);
}
public static int GenerateSequenceHashCode<T>(this ImmutableArray<T> values) where T : notnull {
const int mod = 92821;
var hash = 17;
unchecked {
foreach (var value in values)
hash = hash * mod + value.GetHashCode();
}
return hash;
}
public static int GenerateSequenceHashCode<T>(this Nullable<ImmutableArray<T>> values) where T : notnull => values != null ? values.GenerateSequenceHashCode() : 0;
}
