2.0.1: Fixed a bug where arrays in (Wrapper)ValueObjects would trip the generator. (#19)

Author: Timovzl

DomainModeling.Generator/NamespaceSymbolExtensions.cs

@@ -1,4 +1,4 @@
-using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis;
 
 namespace Architect.DomainModeling.Generator;
 
@@ -12,25 +12,28 @@ internal static class NamespaceSymbolExtensions
 	/// </summary>
 	public static bool IsInSystemNamespace(this INamespaceSymbol namespaceSymbol)
 	{
-		while (namespaceSymbol.ContainingNamespace is not null)
+		while (namespaceSymbol?.ContainingNamespace is not null)
 			namespaceSymbol = namespaceSymbol.ContainingNamespace;
 
-		return namespaceSymbol.Name == "System";
+		return namespaceSymbol?.Name == "System";
 	}
 
 	/// <summary>
 	/// Returns whether the given <see cref="INamedTypeSymbol"/> has the given <paramref name="fullName"/>.
 	/// </summary>
-	public static bool HasFullName(this INamespaceSymbol namespaceSymbol, string fullName)
+	public static bool HasFullName(this INamespaceSymbol? namespaceSymbol, string fullName)
 	{
 		return namespaceSymbol.HasFullName(fullName.AsSpan());
 	}
 
 	/// <summary>
 	/// Returns whether the given <see cref="INamedTypeSymbol"/> has the given <paramref name="fullName"/>.
 	/// </summary>
-	public static bool HasFullName(this INamespaceSymbol namespaceSymbol, ReadOnlySpan<char> fullName)
+	public static bool HasFullName(this INamespaceSymbol? namespaceSymbol, ReadOnlySpan<char> fullName)
 	{
+		if (namespaceSymbol is null)
+			return false;
+
 		do
 		{
 			var length = namespaceSymbol.Name.Length;

DomainModeling.Generator/TypeSymbolExtensions.cs

@@ -43,7 +43,7 @@ public static bool IsType(this ITypeSymbol typeSymbol, ITypeSymbol comparand)
 
 		chars = chars.Slice(0, chars.Length - freeBuffer.Length);
 		if (containingNamespace?.IsGlobalNamespace != false)
-			chars = typeSymbol.ContainingNamespace.ToString().AsSpan();
+			chars = (typeSymbol.ContainingNamespace?.ToString() ?? "").AsSpan();
 
 		if (!typeSymbol.IsType(typeSymbol.Name.AsSpan(), chars))
 			return false;
@@ -333,6 +333,11 @@ public static bool IsEnumerable(this ITypeSymbol typeSymbol, out INamedTypeSymbo
 		if (!typeSymbol.IsOrImplementsInterface(type => type.IsType("IEnumerable", "System.Collections", generic: false), out var nonGenericEnumerableInterface))
 			return false;
 
+		if (typeSymbol.Kind == SymbolKind.ArrayType)
+		{
+			elementType = ((IArrayTypeSymbol)typeSymbol).ElementType as INamedTypeSymbol;
+			return true;
+		}
 		if (typeSymbol.IsOrImplementsInterface(type => type.IsType("IList", "System.Collections.Generic", generic: true), out var interf))
 		{
 			elementType = interf.TypeArguments[0] as INamedTypeSymbol;

DomainModeling.Generator/ValueObjectGenerator.cs

@@ -148,7 +148,7 @@ private static bool FilterSyntaxNode(SyntaxNode node, CancellationToken cancella
 		{
 			dataMemberHashCode = tuple.Member.Name.GetStableHashCode64(dataMemberHashCode);
 			dataMemberHashCode = ":".GetStableHashCode64(dataMemberHashCode);
-			dataMemberHashCode = tuple.Type.ContainingNamespace.ToString().GetStableHashCode64(dataMemberHashCode);
+			dataMemberHashCode = (tuple.Type.ContainingNamespace?.ToString() ?? "").GetStableHashCode64(dataMemberHashCode); // Arrays have no namespace
 			dataMemberHashCode = ".".GetStableHashCode64(dataMemberHashCode);
 			dataMemberHashCode = tuple.Type.Name.GetStableHashCode64(dataMemberHashCode);
 			dataMemberHashCode = "&".GetStableHashCode64(dataMemberHashCode);
@@ -288,7 +288,7 @@ public bool Equals({typeName}? other)
 		{(existingComponents.HasFlags(ValueObjectTypeComponents.EqualsMethod) ? " */" : "")}
 
 		/// <summary>
-		/// Provides type inference when comparing types that are completed 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.
+		/// 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)
@@ -307,7 +307,7 @@ public int CompareTo({typeName}? other)
 		}}
 
 		/// <summary>
-		/// Provides type inference when comparing types that are completed 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.
+		/// 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)

DomainModeling.Tests/ValueObjectTests.cs

@@ -1086,6 +1086,25 @@ public ImmutableArrayValueObject(IEnumerable<string> values)
 			}
 		}
 
+		/// <summary>
+		/// Should merely compile.
+		/// </summary>
+		[Obsolete("Should merely compile.", error: true)]
+		[SourceGenerated]
+		public sealed partial class ArrayValueObject : ValueObject
+		{
+			protected override StringComparison StringComparison => StringComparison.OrdinalIgnoreCase;
+
+			public string?[]? StringValues { get; }
+			public int?[] IntValues { get; }
+
+			public ArrayValueObject(string?[]? stringValues, int?[] intValues)
+			{
+				this.StringValues = stringValues;
+				this.IntValues = intValues;
+			}
+		}
+
 		[SourceGenerated]
 		public sealed partial class CustomCollectionValueObject : ValueObject
 		{

DomainModeling.Tests/WrapperValueObjectTests.cs

@@ -508,6 +508,18 @@ public CustomCollection(string value)
 			}
 		}
 
+		[SourceGenerated]
+		[Obsolete("Should merely compile.", error: true)]
+		public sealed partial class StringArrayValue : WrapperValueObject<string?[]>
+		{
+		}
+
+		[SourceGenerated]
+		[Obsolete("Should merely compile.", error: true)]
+		public sealed partial class DecimalArrayValue : WrapperValueObject<decimal?[]>
+		{
+		}
+
 		/// <summary>
 		/// Should merely compile.
 		/// </summary>

DomainModeling/DomainModeling.csproj

@@ -13,14 +13,17 @@
 	</PropertyGroup>
 
 	<PropertyGroup>
-		<VersionPrefix>2.0.0</VersionPrefix>
+		<VersionPrefix>2.0.1</VersionPrefix>
 		<Description>
 A complete Domain-Driven Design (DDD) toolset for implementing domain models, including base types and source generators.
 
 https://github.com/TheArchitectDev/Architect.DomainModeling
 
 Release notes:
 
+2.0.1:
+- Fixed a bug where arrays in (Wrapper)ValueObjects would trip the generator.
+
 2.0.0:
 - BREAKING: Generated DummyBuilders now use UTC datetimes for generated defaults and for interpreting datetime strings.
 - Semi-breaking: Generated types no longer add [Serializable] attribute, since there would be no way to remove it.