Moved Equals() and Compare() helpers from generated into helper class.

Author: Timovzl

DomainModeling.Generator/IdentityGenerator.cs

@@ -581,7 +581,7 @@ namespace {containingNamespace}
 		static {idTypeName} IValueWrapper<{idTypeName}, {underlyingTypeFullyQualifiedName}>.Deserialize({underlyingTypeFullyQualifiedName} value)
 		{{
 			{(existingComponents.HasFlags(IdTypeComponents.UnsettableValue) ? "// To instead get safe syntax, make the Value property '{ get; private init; }' (or let the source generator implement it)" : "")}
-			{(existingComponents.HasFlags(IdTypeComponents.UnsettableValue) ? $"return System.Runtime.CompilerServices.Unsafe.As<{underlyingTypeFullyQualifiedName}, {idTypeName}>(ref value);" : "")}
+			{(existingComponents.HasFlags(IdTypeComponents.UnsettableValue) ? $"return Unsafe.As<{underlyingTypeFullyQualifiedName}, {idTypeName}>(ref value);" : "")}
 			{(existingComponents.HasFlags(IdTypeComponents.UnsettableValue) ? "//" : "")}return new {idTypeName}() {{ Value = value }};
 		}}
 		{(existingComponents.HasFlags(IdTypeComponents.DeserializeFromUnderlying) ? "*/" : "")}

DomainModeling.Generator/TypeSymbolExtensions.cs

@@ -684,7 +684,7 @@ public static string CreateEqualityExpression(this ITypeSymbol typeSymbol, strin
 		// DO NOT REORDER
 
 		// Not yet source-generated
-		if (typeSymbol.TypeKind == TypeKind.Error) return $"Equals(this.{memberName}, other.{memberName})";
+		if (typeSymbol.TypeKind == TypeKind.Error) return $"{ComparisonsNamespace}.InferredTypeDefaultComparer.Equals(this.{memberName}, other.{memberName})";
 
 		if (typeSymbol.SpecialType == SpecialType.System_String) return String.Format(stringVariant, memberName);
 
@@ -733,7 +733,7 @@ public static string CreateComparisonExpression(this ITypeSymbol typeSymbol, str
 		// DO NOT REORDER
 
 		// Not yet source-generated
-		if (typeSymbol.TypeKind == TypeKind.Error) return $"Compare(this.{memberName}, other.{memberName})";
+		if (typeSymbol.TypeKind == TypeKind.Error) return $"{ComparisonsNamespace}.InferredTypeDefaultComparer.Compare(this.{memberName}, other.{memberName})";
 
 		// Collections have not been implemented, as we do not generate CompareTo() if any data member is not IComparable (as is the case for collections)
 

DomainModeling.Generator/ValueObjectGenerator.cs

@@ -322,33 +322,14 @@ public bool Equals({typeName}? other)
 		}}
 		{(existingComponents.HasFlags(ValueObjectTypeComponents.EqualsMethod) ? " */" : "")}
 
-		/// <summary>
-		/// Provides type inference when comparing types that are entirely source-generated. The current code's source generator does not know the appropriate namespace, because the type is being generated at the same time, thus necessitating type inference.
-		/// </summary>
-		[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-		private static bool Equals<T>(T left, T right)
-		{{
-			return EqualityComparer<T>.Default.Equals(left, right);
-		}}
-
 		{(existingComponents.HasFlags(ValueObjectTypeComponents.CompareToMethod) ? "/*" : "")}
-		{(isComparable ? "" : "/*")}
-		// This method is generated only if the ValueObject implements IComparable<T> against its own type and each data member implements IComparable<T> against its own type
+		{(isComparable ? "" : "/* Generated only if the ValueObject implements IComparable<T> against its own type and each data member implements IComparable<T> against its own type")}
 		public int CompareTo({typeName}? other)
 		{{
 			if (other is null) return +1;
 
 			{compareToBodyIfInstanceNonNull}
 		}}
-
-		/// <summary>
-		/// Provides type inference when comparing types that are entirely source-generated. The current code's source generator does not know the appropriate namespace, because the type is being generated at the same time, thus necessitating type inference.
-		/// </summary>
-		[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-		private static int Compare<T>(T left, T right)
-		{{
-			return Comparer<T>.Default.Compare(left, right);
-		}}
 		{(isComparable ? "" : "*/")}
 		{(existingComponents.HasFlags(ValueObjectTypeComponents.CompareToMethod) ? "*/" : "")}
 

DomainModeling.Generator/WrapperValueObjectGenerator.cs

@@ -495,7 +495,7 @@ namespace {containingNamespace}
 
 		{(existingComponents.HasFlags(WrapperValueObjectTypeComponents.DeserializeFromUnderlying) ? "/*" : "")}
 		{(existingComponents.HasFlags(WrapperValueObjectTypeComponents.UnsettableValue) ? $@"
-		[System.Runtime.CompilerServices.UnsafeAccessor(System.Runtime.CompilerServices.UnsafeAccessorKind.Field, Name = ""{valueFieldName}"")]
+		[UnsafeAccessor(UnsafeAccessorKind.Field, Name = ""{valueFieldName}"")]
 		private static extern ref {underlyingTypeFullyQualifiedName} GetValueFieldReference({typeName} instance);" : "")}
 
 		/// <summary>

DomainModeling/Comparisons/InferredTypeDefaultComparer.cs

@@ -0,0 +1,21 @@
+using System.Runtime.CompilerServices;
+
+namespace Architect.DomainModeling.Comparisons;
+
+/// <summary>
+/// Performs default comparisons with type inference, where the standard syntax does not allow for type inference.
+/// </summary>
+public static class InferredTypeDefaultComparer
+{
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool Equals<T>(T left, T right)
+	{
+		return EqualityComparer<T>.Default.Equals(left, right);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static int Compare<T>(T left, T right)
+	{
+		return Comparer<T>.Default.Compare(left, right);
+	}
+}

DomainModeling/DomainModeling.csproj

@@ -52,6 +52,7 @@ Correct string comparisons with EF:
 
 Performance:
 - Enhancement: Reduced assembly size by having source-generated WrapperValueObject/Identity types use generic JSON serializers instead of generating their own.
+- Enhancement: Reduced assembly size by moving the type-inference Equals() and Compare() helpers on generated ValueObjects into a helper class.
 - Enhancement: Improved source generator performance.
 
 Misc improvements: