diff --git a/Buildenator/CodeAnalysis/ITypedSymbol.cs b/Buildenator/CodeAnalysis/ITypedSymbol.cs index a693a13..acce241 100644 --- a/Buildenator/CodeAnalysis/ITypedSymbol.cs +++ b/Buildenator/CodeAnalysis/ITypedSymbol.cs @@ -7,6 +7,12 @@ internal interface ITypedSymbol string SymbolName { get; } string SymbolPascalName { get; } string TypeFullName { get; } + /// + /// Gets the type name suitable for use as a NullBox generic parameter. + /// For nullable reference types, returns the non-nullable version. + /// For nullable value types, returns the type as-is since Nullable<T> is the actual type. + /// + string NonNullableTypeFullName { get; } string TypeName { get; } string UnderScoreName { get; } diff --git a/Buildenator/CodeAnalysis/TypedSymbol.cs b/Buildenator/CodeAnalysis/TypedSymbol.cs index 68d6e67..bb620de 100644 --- a/Buildenator/CodeAnalysis/TypedSymbol.cs +++ b/Buildenator/CodeAnalysis/TypedSymbol.cs @@ -56,6 +56,35 @@ private TypedSymbol( private string? _typeFullName; public string TypeFullName => _typeFullName ??= Type.ToDisplayString(); + private string? _nonNullableTypeFullName; + /// + /// Gets the type name suitable for use as a NullBox generic parameter. + /// For nullable reference types (e.g., "string?", "Dictionary<K,V>?"), returns the non-nullable version. + /// For nullable value types (e.g., "int?"), returns the type as-is since Nullable<T> is the actual type. + /// + public string NonNullableTypeFullName => _nonNullableTypeFullName ??= GetNonNullableTypeFullName(); + + private string GetNonNullableTypeFullName() + { + // For nullable value types (e.g., int?, DateTime?), keep the nullable form + // because Nullable is the actual type, not just an annotation + if (Type.TypeKind == TypeKind.Struct && Type is INamedTypeSymbol namedType && + namedType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) + { + return TypeFullName; + } + + // For nullable reference types, strip the nullable annotation + // This handles cases like string?, Dictionary?, etc. + if (Type.NullableAnnotation == NullableAnnotation.Annotated) + { + return Type.WithNullableAnnotation(NullableAnnotation.NotAnnotated).ToDisplayString(); + } + + // For non-nullable types, return as-is + return TypeFullName; + } + public string TypeName => Type.Name; public string SymbolPascalName => Symbol.PascalCaseName(); diff --git a/Buildenator/Generators/ConstructorsGenerator.cs b/Buildenator/Generators/ConstructorsGenerator.cs index 13bc7cf..19c7dc5 100644 --- a/Buildenator/Generators/ConstructorsGenerator.cs +++ b/Buildenator/Generators/ConstructorsGenerator.cs @@ -84,11 +84,12 @@ private static string GenerateEmptyCollectionInitialization(ITypedSymbol typedSy { var fieldName = typedSymbol.UnderScoreName; var typeFullName = typedSymbol.TypeFullName; + var nonNullableTypeFullName = typedSymbol.NonNullableTypeFullName; // For concrete dictionary types, create new instance if (collectionMetadata is ConcreteDictionaryMetadata) { - return $"{fieldName} = new {DefaultConstants.NullBox}<{typeFullName}>(new {typeFullName}());"; + return $"{fieldName} = new {DefaultConstants.NullBox}<{typeFullName}>(new {nonNullableTypeFullName}());"; } // For interface dictionary types, create a Dictionary @@ -103,7 +104,7 @@ private static string GenerateEmptyCollectionInitialization(ITypedSymbol typedSy // Standard .NET collections (List, HashSet, Collection, etc.) all support this. if (collectionMetadata is ConcreteCollectionMetadata) { - return $"{fieldName} = new {DefaultConstants.NullBox}<{typeFullName}>(new {typeFullName}());"; + return $"{fieldName} = new {DefaultConstants.NullBox}<{typeFullName}>(new {nonNullableTypeFullName}());"; } // For interface collection types, create a List diff --git a/Buildenator/Generators/PropertiesStringGenerator.cs b/Buildenator/Generators/PropertiesStringGenerator.cs index b330061..ea5bcba 100644 --- a/Buildenator/Generators/PropertiesStringGenerator.cs +++ b/Buildenator/Generators/PropertiesStringGenerator.cs @@ -189,9 +189,12 @@ private string GenerateMethodDefinitionHeader(ITypedSymbol typedSymbol) => $"public {_builder.FullName} {CreateMethodName(typedSymbol)}({typedSymbol.GenerateMethodParameterDefinition()})"; private static string GenerateValueAssignment(ITypedSymbol typedSymbol) - => typedSymbol.IsMockable() - ? $"{DefaultConstants.SetupActionLiteral}({typedSymbol.UnderScoreName})" - : $"{typedSymbol.UnderScoreName} = new {DefaultConstants.NullBox}<{typedSymbol.TypeFullName}>({DefaultConstants.ValueLiteral})"; + { + if (typedSymbol.IsMockable()) + return $"{DefaultConstants.SetupActionLiteral}({typedSymbol.UnderScoreName})"; + + return $"{typedSymbol.UnderScoreName} = new {DefaultConstants.NullBox}<{typedSymbol.TypeFullName}>({DefaultConstants.ValueLiteral})"; + } private string CreateMethodName(ITypedSymbol property) => $"{_builder.BuildingMethodsPrefix}{property.SymbolPascalName}"; @@ -219,7 +222,7 @@ private string GenerateAddToMethodDefinition(ITypedSymbol typedSymbol) }} else {{ - dictionary = new {typedSymbol.TypeFullName}(); + dictionary = new {typedSymbol.NonNullableTypeFullName}(); }} foreach (var item in items) @@ -264,7 +267,7 @@ private string GenerateAddToMethodDefinition(ITypedSymbol typedSymbol) }} else {{ - collection = new {typedSymbol.TypeFullName}(); + collection = new {typedSymbol.NonNullableTypeFullName}(); }} foreach (var item in items) @@ -315,13 +318,12 @@ private string GenerateChildBuilderMethodDefinition(ITypedSymbol typedSymbol) var methodName = CreateMethodName(typedSymbol); var fieldName = typedSymbol.UnderScoreName; - var entityTypeName = typedSymbol.TypeFullName; return $@"public {_builder.FullName} {methodName}(System.Func<{childBuilderName}, {childBuilderName}> configure{typedSymbol.SymbolPascalName}) {{ var childBuilder = new {childBuilderName}(); childBuilder = configure{typedSymbol.SymbolPascalName}(childBuilder); - {fieldName} = new {DefaultConstants.NullBox}<{entityTypeName}>(childBuilder.Build()); + {fieldName} = new {DefaultConstants.NullBox}<{typedSymbol.TypeFullName}>(childBuilder.Build()); return this; }}"; } @@ -347,7 +349,7 @@ private string GenerateChildBuilderAddToMethodDefinition(ITypedSymbol typedSymbo }} else {{ - collection = new {typedSymbol.TypeFullName}(); + collection = new {typedSymbol.NonNullableTypeFullName}(); }} foreach (var configure in configures) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4876234..f216d04 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## Unreleased + +### Fixed +- **Nullable dictionary support**: Fixed compilation error when models have nullable dictionary properties (e.g., `Dictionary?`, `IDictionary?`, `IReadOnlyDictionary?`). The generator now correctly handles nullable reference types in `NullBox` type parameters by stripping the nullable annotation. + ## 8.7.0.0 - 2025-11-27 ### Added diff --git a/Tests/Buildenator.IntegrationTests.SharedEntitiesNullable/EntityWithNullableDictionary.cs b/Tests/Buildenator.IntegrationTests.SharedEntitiesNullable/EntityWithNullableDictionary.cs new file mode 100644 index 0000000..68da425 --- /dev/null +++ b/Tests/Buildenator.IntegrationTests.SharedEntitiesNullable/EntityWithNullableDictionary.cs @@ -0,0 +1,41 @@ +using System.Collections.Generic; + +namespace Buildenator.IntegrationTests.SharedEntitiesNullable +{ + /// + /// Entity used to test nullable dictionary handling in generated builders. + /// Tests various nullable dictionary types. + /// + public class EntityWithNullableDictionary + { + /// + /// Nullable Dictionary property + /// + public Dictionary? Metadata { get; set; } + + /// + /// Nullable IDictionary property + /// + public IDictionary? Items { get; set; } + + /// + /// Nullable IReadOnlyDictionary property + /// + public IReadOnlyDictionary? Settings { get; set; } + + /// + /// Another nullable Dictionary property + /// + public Dictionary? Scores { get; set; } + + /// + /// Simple non-dictionary property for comparison + /// + public string? Name { get; set; } + + /// + /// Nullable value type property to test int? handling + /// + public int? Count { get; set; } + } +} diff --git a/Tests/Buildenator.IntegrationTests.SourceNullable/Builders/EntityWithNullableDictionaryBuilder.cs b/Tests/Buildenator.IntegrationTests.SourceNullable/Builders/EntityWithNullableDictionaryBuilder.cs new file mode 100644 index 0000000..e4f4b6f --- /dev/null +++ b/Tests/Buildenator.IntegrationTests.SourceNullable/Builders/EntityWithNullableDictionaryBuilder.cs @@ -0,0 +1,10 @@ +using Buildenator.Abstraction; +using Buildenator.IntegrationTests.SharedEntitiesNullable; + +namespace Buildenator.IntegrationTests.SourceNullable.Builders +{ + [MakeBuilder(typeof(EntityWithNullableDictionary))] + public partial class EntityWithNullableDictionaryBuilder + { + } +} diff --git a/Tests/Buildenator.IntegrationTests/BuildersGeneratorNullableTests.cs b/Tests/Buildenator.IntegrationTests/BuildersGeneratorNullableTests.cs index f8e44cc..738eb6d 100644 --- a/Tests/Buildenator.IntegrationTests/BuildersGeneratorNullableTests.cs +++ b/Tests/Buildenator.IntegrationTests/BuildersGeneratorNullableTests.cs @@ -258,5 +258,110 @@ public void BuildersGenerator_ReadOnlyProperty_ShouldCreateMethodForSettingItsVa builder.WithPrivateField(privateField); builder.Build().PrivateField.Should().BeEquivalentTo(privateField); } + + [Theory] + [AutoData] + public void BuildersGenerator_NullableDictionary_WithMethodShouldSetValue(string key, string value) + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + var metadata = new Dictionary { { key, value } }; + + // Act + var result = builder + .WithMetadata(metadata) + .Build(); + + // Assert + _ = result.Metadata.Should().NotBeNull(); + _ = result.Metadata.Should().HaveCount(1); + _ = result.Metadata![key].Should().Be(value); + } + + [Theory] + [AutoData] + public void BuildersGenerator_NullableIDictionary_WithMethodShouldSetValue(int key, string value) + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + var items = new Dictionary { { key, value } }; + + // Act + var result = builder + .WithItems(items) + .Build(); + + // Assert + _ = result.Items.Should().NotBeNull(); + _ = result.Items.Should().HaveCount(1); + _ = result.Items![key].Should().Be(value); + } + + [Fact] + public void BuildersGenerator_NullableDictionary_WithNullValueShouldWork() + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + + // Act + var result = builder + .WithMetadata(null) + .Build(); + + // Assert + _ = result.Metadata.Should().BeNull(); + } + + [Theory] + [AutoData] + public void BuildersGenerator_NullableDictionary_AddToMethodShouldAddItems(string key1, string value1, string key2, string value2) + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + + // Act + var result = builder + .AddToMetadata( + new KeyValuePair(key1, value1), + new KeyValuePair(key2, value2)) + .Build(); + + // Assert + _ = result.Metadata.Should().NotBeNull(); + _ = result.Metadata.Should().HaveCount(2); + _ = result.Metadata![key1].Should().Be(value1); + _ = result.Metadata[key2].Should().Be(value2); + } + + [Theory] + [AutoData] + public void BuildersGenerator_NullableValueType_WithMethodShouldSetValue(int value) + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + + // Act + var result = builder + .WithCount(value) + .Build(); + + // Assert + _ = result.Count.Should().Be(value); + } + + [Fact] + public void BuildersGenerator_NullableValueType_WithNullValueShouldWork() + { + // Arrange + var builder = EntityWithNullableDictionaryBuilder.EntityWithNullableDictionary; + + // Act + var result = builder + .WithCount(null) + .Build(); + + // Assert + _ = result.Count.Should().BeNull(); + } } }