FastClonerContext

Author: lofcz

src/FastCloner.SourceGenerator.Shared/FastCloner.SourceGenerator.Shared.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
         <LangVersion>preview</LangVersion>
         <Nullable>enable</Nullable>
+        <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
     </PropertyGroup>
 
 </Project>

src/FastCloner.SourceGenerator.Shared/FastClonerContext.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace FastCloner.SourceGenerator.Shared;
+
+/// <summary>
+/// Base class for FastCloner contexts.
+/// Inherit from this class and annotate with [FastClonerRegister] to generate a cloning context.
+/// </summary>
+public abstract class FastClonerContext
+{
+    /// <summary>
+    /// Clones the object using the generated dispatch logic or falls back to reflection.
+    /// </summary>
+    /// <param name="input">The object to clone.</param>
+    /// <returns>The cloned object.</returns>
+    public abstract object Clone(object input);
+
+    /// <summary>
+    /// Checks if the type is handled by this context (i.e. has a source generated clone method).
+    /// </summary>
+    /// <param name="type">The type to check.</param>
+    /// <returns>True if the type is handled, false otherwise.</returns>
+    public abstract bool IsHandled(Type type);
+
+    /// <summary>
+    /// Tries to clone the object using the source generated clone method.
+    /// Returns false if the type is not handled by this context.
+    /// </summary>
+    /// <param name="input">The object to clone.</param>
+    /// <param name="clone">The cloned object if successful, null otherwise.</param>
+    /// <returns>True if the object was cloned, false otherwise.</returns>
+    public abstract bool TryClone(object input, [NotNullWhen(true)] out object? clone);
+}

src/FastCloner.SourceGenerator.Shared/FastClonerRegisterAttribute.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FastCloner.SourceGenerator.Shared;
+
+/// <summary>
+/// Registers a type to be included in the source generated FastClonerContext.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public class FastClonerRegisterAttribute : Attribute
+{
+    public Type[] TypesToRegister { get; }
+
+    public FastClonerRegisterAttribute(params Type[] typesToRegister)
+    {
+        TypesToRegister = typesToRegister;
+    }
+}

src/FastCloner.SourceGenerator.Shared/FcGeneratedCloneState.cs

@@ -0,0 +1,50 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace FastCloner.SourceGenerator.Shared;
+
+/// <summary>
+/// State for tracking circular references during cloning.
+/// Used by source-generated clone methods to detect and handle cycles.
+/// Thread-safe for concurrent clone operations.
+/// </summary>
+public sealed class FcGeneratedCloneState
+{
+    private readonly ConcurrentDictionary<object, object> _knownRefs = new ConcurrentDictionary<object, object>(ReferenceEqualityComparer.Instance);
+
+    /// <summary>
+    /// Registers a known reference mapping from original to clone.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddKnownRef(object original, object clone)
+    {
+        if (original != null)
+        {
+            _knownRefs.TryAdd(original, clone);
+        }
+    }
+
+    /// <summary>
+    /// Gets the previously cloned object for the given original, if any.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public object? GetKnownRef(object original)
+    {
+        if (original == null) return null;
+        return _knownRefs.TryGetValue(original, out var clone) ? clone : null;
+    }
+
+    /// <summary>
+    /// Reference equality comparer for proper circular reference detection.
+    /// Uses object identity (ReferenceEquals) rather than value equality.
+    /// </summary>
+    private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
+    {
+        public static readonly ReferenceEqualityComparer Instance = new ReferenceEqualityComparer();
+        
+        bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
+        int IEqualityComparer<object>.GetHashCode(object obj) => RuntimeHelpers.GetHashCode(obj);
+    }
+}
+

src/FastCloner.SourceGenerator.Shared/Polyfill.cs

@@ -0,0 +1,20 @@
+using System;
+
+#if !NET5_0_OR_GREATER
+
+// ReSharper disable once CheckNamespace
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    sealed class NotNullWhenAttribute : Attribute
+    {
+        public NotNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+
+        public bool ReturnValue { get; }
+    }
+}
+
+#endif

src/FastCloner.SourceGenerator/ClassCloneBodyGenerator.cs

@@ -0,0 +1,134 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace FastCloner.SourceGenerator;
+
+/// <summary>
+/// Helper class for generating class clone body code.
+/// Shared between ContextCodeGenerator and CloneCodeGenerator to avoid duplication.
+/// </summary>
+internal static class ClassCloneBodyGenerator
+{
+    /// <summary>
+    /// Checks if FormatterServices using statement is needed for the given type.
+    /// </summary>
+    public static bool NeedsFormatterServices(TypeModel model)
+    {
+        return !model.HasParameterlessConstructor && !model.IsStruct;
+    }
+
+    /// <summary>
+    /// Checks if any of the given types need FormatterServices.
+    /// </summary>
+    public static bool NeedsFormatterServices(IEnumerable<TypeModel> types)
+    {
+        foreach (var type in types)
+        {
+            if (NeedsFormatterServices(type))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Writes the code to instantiate a class, handling both parameterless and non-parameterless constructors.
+    /// </summary>
+    /// <param name="sb">StringBuilder to write to</param>
+    /// <param name="typeName">Name of the type to instantiate</param>
+    /// <param name="hasParameterlessConstructor">Whether the type has a parameterless constructor</param>
+    public static void WriteInstanceCreation(StringBuilder sb, string typeName, bool hasParameterlessConstructor)
+    {
+        if (hasParameterlessConstructor)
+        {
+            sb.AppendLine($"            var result = new {typeName}();");
+        }
+        else
+        {
+            // Use FormatterServices.GetUninitializedObject to create instance without calling constructor
+            sb.AppendLine($"            var result = ({typeName})FormatterServices.GetUninitializedObject(typeof({typeName}));");
+        }
+    }
+
+    /// <summary>
+    /// Writes the complete class clone body code.
+    /// </summary>
+    /// <param name="ctx">The clone generator context</param>
+    /// <param name="typeName">Name of the type to clone</param>
+    /// <param name="useState">Whether to use state tracking for circular references</param>
+    /// <param name="stateVarName">Name of the state variable (null if not using state)</param>
+    /// <param name="useNullConditional">Whether to use null-conditional operator (?.) when calling AddKnownRef</param>
+    public static void WriteClassCloneBody(
+        CloneGeneratorContext ctx,
+        string typeName,
+        bool useState,
+        string? stateVarName = null,
+        bool useNullConditional = false)
+    {
+        var sb = ctx.Source;
+        var hasParameterlessConstructor = ctx.Model.HasParameterlessConstructor;
+        
+        if (useState)
+        {
+            // When tracking circular references, we must register the instance BEFORE cloning members
+            // to avoid infinite recursion (StackOverflowException) in case of cycles.
+            // This requires us to instantiate first, then register, then assign members.
+            WriteInstanceCreation(sb, typeName, hasParameterlessConstructor);
+            
+            var stateVarForAdd = stateVarName ?? "state";
+            var nullConditional = useNullConditional ? "?" : "";
+            sb.AppendLine($"            {stateVarForAdd}{nullConditional}.AddKnownRef(source, result);");
+            sb.AppendLine();
+
+            foreach (var member in ctx.Model.Members)
+            {
+                MemberCloneGenerator.WriteMemberCloning(ctx, member, "result", "source", stateVarForAdd);
+            }
+            
+            sb.AppendLine();
+            sb.AppendLine("            return result;");
+        }
+        else
+        {
+            // For non-circular types, we can use object initializer syntax if constructor exists
+            if (hasParameterlessConstructor)
+            {
+                sb.AppendLine($"            var result = new {typeName}");
+                sb.AppendLine("            {");
+
+                var memberAssignments = new List<string>();
+                foreach (var member in ctx.Model.Members)
+                {
+                    var assignment = MemberCloneGenerator.GetMemberAssignment(ctx, member, "source", "null");
+                    if (!string.IsNullOrEmpty(assignment))
+                    {
+                        memberAssignments.Add($"                {assignment}");
+                    }
+                }
+
+                if (memberAssignments.Count > 0)
+                {
+                    sb.AppendLine(string.Join(",\n", memberAssignments));
+                }
+
+                sb.AppendLine("            };");
+            }
+            else
+            {
+                // Use FormatterServices.GetUninitializedObject to create instance without calling constructor
+                WriteInstanceCreation(sb, typeName, hasParameterlessConstructor);
+                
+                // Then assign members individually (no state needed for non-circular types)
+                foreach (var member in ctx.Model.Members)
+                {
+                    MemberCloneGenerator.WriteMemberCloning(ctx, member, "result", "source", "null");
+                }
+            }
+            
+            sb.AppendLine();
+            sb.AppendLine("            return result;");
+        }
+    }
+}
+

src/FastCloner.SourceGenerator/CloneCodeGenerator.cs

@@ -46,6 +46,13 @@ private void WriteUsings()
         sb.AppendLine("using System;");
         sb.AppendLine("using System.Collections.Generic;");
         sb.AppendLine("using System.Reflection;");
+        sb.AppendLine("using FastCloner.SourceGenerator.Shared;");
+
+        // Add FormatterServices if type doesn't have parameterless constructor
+        if (ClassCloneBodyGenerator.NeedsFormatterServices(_context.Model))
+        {
+            sb.AppendLine("using System.Runtime.Serialization;");
+        }
 
         // Only add FastCloner using if the library is available
         if (_context.IsFastClonerAvailable)
@@ -73,6 +80,8 @@ private void WriteExtensionClass()
         var fullTypeName = _context.Model.FullyQualifiedName;
         var sb = _context.Source;
 
+        // FcGeneratedCloneState is now in FastCloner.SourceGenerator.Shared - no need to generate it
+
         sb.AppendLine("    /// <summary>");
         sb.AppendLine($"    /// Extension methods for cloning {_context.Model.Name}.");
         sb.AppendLine("    /// </summary>");
@@ -82,12 +91,8 @@ private void WriteExtensionClass()
         // Generate public FastDeepClone() without state parameter
         WritePublicFastDeepCloneMethod(typeName, fullTypeName);
 
-        // Only generate InternalFastDeepClone if circular references are possible
-        // (for types without circular refs, the public method inlines the logic directly)
-        if (_context.CanHaveCircularReferences)
-        {
-            WritePrivateFastDeepCloneMethod(typeName, fullTypeName);
-        }
+        // Always generate InternalFastDeepClone for Clonable types, even if they don't detect circular references
+        WritePrivateFastDeepCloneMethod(typeName, fullTypeName);
 
         // Generate Cloner<T> helper class (private nested class)
         // Must be generated before helpers to register its dependencies
@@ -96,9 +101,6 @@ private void WriteExtensionClass()
         // Generate helper methods for nested types
         CollectionHelperGenerator.GenerateHelpers(_context);
 
-        // Generate FastCloneState helper class (private nested class)
-        WriteFastCloneStateClass();
-
         sb.AppendLine("    }");
     }
 
@@ -218,71 +220,10 @@ private void WriteStructCloneBody(string typeName, string stateVarName = "state"
 
     private void WriteClassCloneBody(string typeName, string fullTypeName, bool useState, string? stateVarName = null)
     {
-        var sb = _context.Source;
-        // Use object initializer syntax instead of MemberwiseClone for better performance
-        // Create new instance using object initializer
-        sb.AppendLine($"            var result = new {typeName}");
-        sb.AppendLine("            {");
-
-        // Generate property/field assignments in object initializer
-        var memberAssignments = new List<string>();
-        foreach (var member in _context.Model.Members)
-        {
-            // Pass null if state isn't needed, or use the provided stateVarName (or "state" as default)
-            var stateVar = useState ? (stateVarName ?? "state") : "null";
-            var assignment = MemberCloneGenerator.GetMemberAssignment(_context, member, "source", stateVar);
-            if (!string.IsNullOrEmpty(assignment))
-            {
-                memberAssignments.Add($"                {assignment}");
-            }
-        }
-
-        if (memberAssignments.Count > 0)
-        {
-            sb.AppendLine(string.Join(",\n", memberAssignments));
-        }
-
-        sb.AppendLine("            };");
-        if (useState)
-        {
-            var stateVarForAdd = stateVarName ?? "state";
-            sb.AppendLine($"            {stateVarForAdd}?.AddKnownRef(source, result);");
-        }
-
-        sb.AppendLine();
-        sb.AppendLine("            return result;");
+        // Use null-conditional operator for CloneCodeGenerator since state might be null
+        ClassCloneBodyGenerator.WriteClassCloneBody(_context, typeName, useState, stateVarName, useNullConditional: true);
     }
 
-    private void WriteFastCloneStateClass()
-    {
-        // Only generate state class if it's actually needed
-        if (!_context.NeedsStateClass)
-            return;
-
-        var sb = _context.Source;
-        sb.AppendLine();
-        sb.AppendLine("        /// <summary>");
-        sb.AppendLine("        /// State for tracking circular references during cloning.");
-        sb.AppendLine("        /// </summary>");
-        sb.AppendLine("        private class FcGeneratedCloneState");
-        sb.AppendLine("        {");
-        sb.AppendLine("            private readonly Dictionary<object, object> _knownRefs = new Dictionary<object, object>();");
-        sb.AppendLine();
-        sb.AppendLine("            public void AddKnownRef(object original, object clone)");
-        sb.AppendLine("            {");
-        sb.AppendLine("                if (original != null)");
-        sb.AppendLine("                {");
-        sb.AppendLine("                    _knownRefs[original] = clone;");
-        sb.AppendLine("                }");
-        sb.AppendLine("            }");
-        sb.AppendLine();
-        sb.AppendLine("            public object? GetKnownRef(object original)");
-        sb.AppendLine("            {");
-        sb.AppendLine("                if (original == null) return null;");
-        sb.AppendLine("                return _knownRefs.TryGetValue(original, out var clone) ? clone : null;");
-        sb.AppendLine("            }");
-        sb.AppendLine("        }");
-    }
 
     private void WriteClonerClass()
     {