feat(generator): enhance synthesized property handling for nullable types and backing field naming

Author: koenbeuk

docs/guide/migration-from-projectables.md

@@ -143,7 +143,7 @@ Pick based on whether you want the generator to declare the target property for
 ```csharp
 // Before (Projectables)
 [Projectable(UseMemberBody = nameof(FullNameProjection))]
-public partial string FullName { get; init; }
+public string FullName { get; init; }
 private string FullNameProjection => LastName + ", " + FirstName;
 
 // After (ExpressiveSharp) -- partial class, stub only; FullName is generated

src/ExpressiveSharp.Generator/Emitter/SynthesizedPropertyEmitter.cs

@@ -40,14 +40,14 @@ public static string BuildSource(SynthesizedPropertySpec spec)
         var baseIndent = hasNamespace ? "    " : "";
         var nestingDepth = spec.ContainingTypePath.Count;
 
-        // Emit partial-class wrappers for any enclosing (nested) types, from outermost in.
-        // The innermost is the type we attach the synthesized member to.
+        // Emit partial wrappers for any enclosing (nested) types, from outermost in.
+        // Each level uses its actual type keyword so a struct/record container doesn't get
+        // emitted as `partial class`.
         for (var i = 0; i < nestingDepth; i++)
         {
             var indent = baseIndent + new string(' ', i * 4);
             var name = spec.ContainingTypePath[i];
-            // Only the innermost knows its keyword; enclosing nests are "partial class" as a safe default.
-            var keyword = i == nestingDepth - 1 ? spec.ContainingTypeKeyword : "class";
+            var keyword = spec.ContainingTypeKeywords[i];
             sb.AppendLine($"{indent}partial {keyword} {name}");
             sb.AppendLine($"{indent}{{");
         }
@@ -72,43 +72,34 @@ public static string BuildSource(SynthesizedPropertySpec spec)
 
     private static string BuildCoalesceBody(SynthesizedPropertySpec spec, string indent)
     {
-        var fieldName = MakeBackingFieldName(spec.PropertyName);
         var stubCall = spec.StubIsMethod ? $"{spec.StubMemberName}()" : spec.StubMemberName;
 
         var sb = new StringBuilder();
-        sb.AppendLine($"{indent}private {spec.BackingFieldTypeFqn} {fieldName};");
+        sb.AppendLine($"{indent}private {spec.BackingFieldTypeFqn} {spec.BackingFieldName};");
         sb.AppendLine($"{indent}public {spec.PropertyTypeFqn} {spec.PropertyName}");
         sb.AppendLine($"{indent}{{");
-        sb.AppendLine($"{indent}    get => {fieldName} ?? {stubCall};");
-        sb.AppendLine($"{indent}    init => {fieldName} = value;");
+        sb.AppendLine($"{indent}    get => {spec.BackingFieldName} ?? {stubCall};");
+        sb.AppendLine($"{indent}    init => {spec.BackingFieldName} = value;");
         sb.AppendLine($"{indent}}}");
         return sb.ToString();
     }
 
     private static string BuildTernaryBody(SynthesizedPropertySpec spec, string indent)
     {
-        var fieldName = MakeBackingFieldName(spec.PropertyName);
-        var flagName = MakeHasValueFlagName(spec.PropertyName);
         var stubCall = spec.StubIsMethod ? $"{spec.StubMemberName}()" : spec.StubMemberName;
 
         var sb = new StringBuilder();
-        sb.AppendLine($"{indent}private {spec.BackingFieldTypeFqn} {fieldName};");
-        sb.AppendLine($"{indent}private bool {flagName};");
+        sb.AppendLine($"{indent}private {spec.BackingFieldTypeFqn} {spec.BackingFieldName};");
+        sb.AppendLine($"{indent}private bool {spec.HasValueFlagName};");
         sb.AppendLine($"{indent}public {spec.PropertyTypeFqn} {spec.PropertyName}");
         sb.AppendLine($"{indent}{{");
-        sb.AppendLine($"{indent}    get => {flagName} ? {fieldName} : {stubCall};");
+        sb.AppendLine($"{indent}    get => {spec.HasValueFlagName} ? {spec.BackingFieldName} : {stubCall};");
         sb.AppendLine($"{indent}    init");
         sb.AppendLine($"{indent}    {{");
-        sb.AppendLine($"{indent}        {flagName} = true;");
-        sb.AppendLine($"{indent}        {fieldName} = value;");
+        sb.AppendLine($"{indent}        {spec.HasValueFlagName} = true;");
+        sb.AppendLine($"{indent}        {spec.BackingFieldName} = value;");
         sb.AppendLine($"{indent}    }}");
         sb.AppendLine($"{indent}}}");
         return sb.ToString();
     }
-
-    private static string MakeBackingFieldName(string propertyName) =>
-        "_" + char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1);
-
-    private static string MakeHasValueFlagName(string propertyName) =>
-        "_" + char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1) + "HasValue";
 }

src/ExpressiveSharp.Generator/Interpretation/ExpressivePropertyInterpreter.cs

@@ -23,6 +23,11 @@ namespace ExpressiveSharp.Generator.Interpretation;
 /// </remarks>
 static internal class ExpressivePropertyInterpreter
 {
+    private static readonly SymbolDisplayFormat FullyQualifiedNullableFormat =
+        SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(
+            SymbolDisplayFormat.FullyQualifiedFormat.MiscellaneousOptions
+            | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
+
     public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? GetDescriptor(
         SemanticModel semanticModel,
         PropertyDeclarationSyntax stubProperty,
@@ -107,8 +112,9 @@ public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? G
         // Synthesis spec for the partial-class emitter.
         var returnType = stubSymbol.Type;
         var useTernary = IsNullablePropertyType(returnType);
-        var propertyTypeFqn = returnType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+        var propertyTypeFqn = returnType.ToDisplayString(FullyQualifiedNullableFormat);
         var backingFieldTypeFqn = useTernary ? propertyTypeFqn : MakeNullableTypeFqn(returnType);
+        var (backingFieldName, hasValueFlagName) = ChooseBackingNames(containingType, targetName!, useTernary);
 
         var spec = new SynthesizedPropertySpec
         {
@@ -118,11 +124,14 @@ public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? G
             StubIsMethod = false, // rule 1 enforces property stub
             UseTernaryShape = useTernary,
             BackingFieldTypeFqn = backingFieldTypeFqn,
+            BackingFieldName = backingFieldName,
+            HasValueFlagName = hasValueFlagName,
             ContainingTypeName = containingType.Name,
             ContainingTypeNamespace = containingType.ContainingNamespace.IsGlobalNamespace
                 ? null
                 : containingType.ContainingNamespace.ToDisplayString(),
             ContainingTypePath = GetNestedInClassPath(containingType).ToList(),
+            ContainingTypeKeywords = GetNestedInClassKeywords(containingType).ToList(),
             ContainingTypeKeyword = GetTypeKeyword(containingType),
         };
 
@@ -158,8 +167,9 @@ public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? G
 
         var returnType = stubSymbol.Type;
         var useTernary = IsNullablePropertyType(returnType);
-        var propertyTypeFqn = returnType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+        var propertyTypeFqn = returnType.ToDisplayString(FullyQualifiedNullableFormat);
         var backingFieldTypeFqn = useTernary ? propertyTypeFqn : MakeNullableTypeFqn(returnType);
+        var (backingFieldName, hasValueFlagName) = ChooseBackingNames(containingType, targetName!, useTernary);
 
         return new SynthesizedPropertySpec
         {
@@ -169,11 +179,14 @@ public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? G
             StubIsMethod = false,
             UseTernaryShape = useTernary,
             BackingFieldTypeFqn = backingFieldTypeFqn,
+            BackingFieldName = backingFieldName,
+            HasValueFlagName = hasValueFlagName,
             ContainingTypeName = containingType.Name,
             ContainingTypeNamespace = containingType.ContainingNamespace.IsGlobalNamespace
                 ? null
                 : containingType.ContainingNamespace.ToDisplayString(),
             ContainingTypePath = GetNestedInClassPath(containingType).ToList(),
+            ContainingTypeKeywords = GetNestedInClassKeywords(containingType).ToList(),
             ContainingTypeKeyword = GetTypeKeyword(containingType),
         };
     }
@@ -299,6 +312,40 @@ private static IEnumerable<string> GetNestedInClassPath(ITypeSymbol typeSymbol)
         yield return typeSymbol.Name;
     }
 
+    private static IEnumerable<string> GetNestedInClassKeywords(INamedTypeSymbol typeSymbol)
+    {
+        if (typeSymbol.ContainingType is not null)
+        {
+            foreach (var keyword in GetNestedInClassKeywords(typeSymbol.ContainingType))
+                yield return keyword;
+        }
+        yield return GetTypeKeyword(typeSymbol);
+    }
+
+    private static (string BackingFieldName, string HasValueFlagName) ChooseBackingNames(
+        INamedTypeSymbol containingType, string propertyName, bool useTernary)
+    {
+        var existing = new HashSet<string>(containingType.GetMembers().Select(m => m.Name));
+        var camel = char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1);
+        var basePrefix = "_" + camel;
+
+        // Single suffix shared across the pair so collision-resolved names stay related
+        // (`_foo2` / `_foo2HasValue`, never `_foo2` / `_foo3HasValue`).
+        var suffix = 0;
+        while (true)
+        {
+            var suffixStr = suffix == 0 ? "" : suffix.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            var fieldName = basePrefix + suffixStr;
+            var flagName = basePrefix + suffixStr + "HasValue";
+            var fieldOk = !existing.Contains(fieldName);
+            var flagOk = !useTernary || !existing.Contains(flagName);
+            if (fieldOk && flagOk)
+                return (fieldName, useTernary ? flagName : "");
+            // First retry uses suffix 2 (skip 1 — `_foo1` reads worse than `_foo2`).
+            suffix = suffix == 0 ? 2 : suffix + 1;
+        }
+    }
+
     private static INamedTypeSymbol? FindInheritedMember(INamedTypeSymbol type, string memberName)
     {
         // Walk the base chain — System.Object itself is not interesting for user-defined collisions

src/ExpressiveSharp.Generator/Models/SynthesizedPropertySpec.cs

@@ -37,6 +37,25 @@ internal sealed class SynthesizedPropertySpec
     /// <summary>Containing type path from outermost to target (for nested types).</summary>
     public IReadOnlyList<string> ContainingTypePath { get; set; } = System.Array.Empty<string>();
 
-    /// <summary>Keyword for the containing type declaration (<c>class</c>, <c>record</c>, <c>struct</c>, etc.).</summary>
+    /// <summary>
+    /// Type keyword (<c>class</c>, <c>struct</c>, <c>record</c>, <c>record struct</c>) for each entry in
+    /// <see cref="ContainingTypePath"/>. Same length and ordering as <see cref="ContainingTypePath"/>.
+    /// The last element equals <see cref="ContainingTypeKeyword"/>.
+    /// </summary>
+    public IReadOnlyList<string> ContainingTypeKeywords { get; set; } = System.Array.Empty<string>();
+
+    /// <summary>Keyword for the innermost containing type declaration (<c>class</c>, <c>record</c>, <c>struct</c>, etc.).</summary>
     public string ContainingTypeKeyword { get; set; } = "class";
+
+    /// <summary>
+    /// Name of the backing field for the materialized value. Chosen at interpret time to avoid
+    /// collisions with user-declared members on the containing type.
+    /// </summary>
+    public string BackingFieldName { get; set; } = "";
+
+    /// <summary>
+    /// Name of the "has value" flag field (ternary shape only). Chosen at interpret time to
+    /// avoid collisions with user-declared members on the containing type.
+    /// </summary>
+    public string HasValueFlagName { get; set; } = "";
 }

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ExpressivePropertyTests.NestedInsideNonClassContainer_EmitsCorrectOuterKeyword.verified.txt

@@ -0,0 +1,42 @@
+// <auto-generated/>
+#nullable disable
+
+using ExpressiveSharp.Mapping;
+using Foo;
+
+namespace ExpressiveSharp.Generated
+{
+    static partial class Foo_Outer_Inner 
+    {
+        // [ExpressiveProperty("Name")]
+        // private string NameExpression => FirstName;
+        static global::System.Linq.Expressions.Expression<global::System.Func<global::Foo.Outer.Inner, string>> Name_Expression() 
+        {
+            var p__this = global::System.Linq.Expressions.Expression.Parameter(typeof(global::Foo.Outer.Inner), "@this");
+            var expr_0 = global::System.Linq.Expressions.Expression.Property(p__this, typeof(global::Foo.Outer.Inner).GetProperty("FirstName")); // FirstName
+            return global::System.Linq.Expressions.Expression.Lambda<global::System.Func<global::Foo.Outer.Inner, string>>(expr_0, p__this);
+        }
+    }
+}
+
+
+// ===
+
+// <auto-generated/>
+#nullable enable
+
+namespace Foo
+{
+    partial struct Outer
+    {
+        partial class Inner
+        {
+            private string? _name;
+            public string Name
+            {
+                get => _name ?? NameExpression;
+                init => _name = value;
+            }
+        }
+    }
+}

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ExpressivePropertyTests.NullableReferenceTypeTarget_EmitsTernaryForm.verified.txt

@@ -46,9 +46,9 @@ namespace Foo
 {
     partial class Account
     {
-        private string _fullName;
+        private string? _fullName;
         private bool _fullNameHasValue;
-        public string FullName
+        public string? FullName
         {
             get => _fullNameHasValue ? _fullName : FullNameExpression;
             init

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ExpressivePropertyTests.cs

@@ -184,6 +184,67 @@ partial struct Point {
             result.GeneratedTrees.Select(t => t.ToString())));
     }
 
+    [TestMethod]
+    public Task BackingFieldNameCollision_AppendsSuffix()
+    {
+        // User type already declares `_fullName` — synthesized backing field must avoid the
+        // collision (verified by a string contains assertion rather than full snapshot since
+        // only the field name choice is the contract being tested).
+        var compilation = CreateCompilation(
+            """
+            using ExpressiveSharp.Mapping;
+
+            namespace Foo {
+                partial class Account {
+                    private string? _fullName;
+                    public string FirstName { get; set; } = "";
+                    public string LastName  { get; set; } = "";
+
+                    [ExpressiveProperty("FullName")]
+                    private string FullNameExpression => LastName + ", " + FirstName;
+                }
+            }
+            """);
+        var result = RunExpressiveGenerator(compilation);
+
+        Assert.AreEqual(0, result.Diagnostics.Length);
+        var generated = string.Join("\n", result.GeneratedTrees.Select(t => t.ToString()));
+        StringAssert.Contains(generated, "private string? _fullName2;",
+            "Backing field should be renamed to avoid collision with the user-declared _fullName field.");
+        Assert.IsFalse(generated.Contains("private string? _fullName;\n        public string FullName"),
+            "Synthesized backing field must not be the colliding name `_fullName`.");
+        return Task.CompletedTask;
+    }
+
+    [TestMethod]
+    public Task NestedInsideNonClassContainer_EmitsCorrectOuterKeyword()
+    {
+        // Partial class nested inside a partial struct — outer wrapper must be `partial struct`,
+        // not the previous hard-coded `partial class` (which produced uncompilable output).
+        var compilation = CreateCompilation(
+            """
+            using ExpressiveSharp.Mapping;
+
+            namespace Foo {
+                public partial struct Outer {
+                    public partial class Inner {
+                        public string FirstName { get; set; } = "";
+
+                        [ExpressiveProperty("Name")]
+                        private string NameExpression => FirstName;
+                    }
+                }
+            }
+            """);
+        var result = RunExpressiveGenerator(compilation);
+
+        Assert.AreEqual(0, result.Diagnostics.Length);
+        Assert.AreEqual(2, result.GeneratedTrees.Length);
+
+        return Verifier.Verify(string.Join("\n\n// ===\n\n",
+            result.GeneratedTrees.Select(t => t.ToString())));
+    }
+
     // ── Diagnostic tests ────────────────────────────────────────────────────
 
     [TestMethod]