allow compile time behaviors on types

Author: lofcz

README.md

@@ -71,71 +71,69 @@ var clone = original.FastDeepClone();
 
 ## Advanced Usage
 
-Sometimes, you might want to exclude certain fields/events/properties from cloning:
-```csharp
-private class TestPropsWithIgnored
-{
-    [FastClonerIgnore] // <-- decorate with [FastClonerIgnore] or [NonSerialized]
-    public string B { get; set; } = "My string";
-    public int A { get; set; } = 10;
-}
+### Customizing Clone Behavior
 
-TestPropsWithIgnored original = new TestPropsWithIgnored { A = 42, B = "Test value" };
-TestPropsWithIgnored clone = original.DeepClone(); // clone.B is null (default value of a given type)
-```
+FastCloner supports behavior attributes that control how types and members are cloned:
 
-### Shallow Cloning Members
+| Behavior | Effect |
+|----------|--------|
+| `Clone` | Deep recursive copy |
+| `Reference` | Return original instance unchanged |
+| `Shallow` | `MemberwiseClone` without recursion |
+| `Ignore` | Return `default` |
 
-When you need to copy a reference directly without deep cloning its contents, use `[FastClonerShallow]`.
+#### Compile-time (Attributes)
+
+Apply attributes to **types** or **members**. Member-level attributes override type-level:
 
 ```csharp
-public class TreeNode
+[FastClonerReference]  // Type-level: all usages preserve reference
+public class SharedService { }
+
+public class MyClass
 {
-    public string Name { get; set; }
+    public SharedService Svc { get; set; }      // Uses type-level → Reference
+    
+    [FastClonerBehavior(CloneBehavior.Clone)]   // Member-level override → Clone
+    public SharedService ClonedSvc { get; set; }
 
-    [FastClonerShallow] // <-- reference copied directly
-    public TreeNode Parent { get; set; }
+    [FastClonerIgnore]                          // → null/default
+    public CancellationToken Token { get; set; }
 
-    public List<TreeNode> Children { get; set; }
+    [FastClonerShallow]                         // → Reference copied directly
+    public ParentNode Parent { get; set; }
 }
-
-TreeNode child = new TreeNode { 
-    Name = "Child", 
-    Parent = new TreeNode { Name = "Root" } 
-};
-TreeNode clone = child.DeepClone();
 ```
 
-This differs from `[FastClonerIgnore]` which leaves the member as `null`/default. With `[FastClonerShallow]`, the original reference is preserved.
+Shorthand attributes: `[FastClonerIgnore]`, `[FastClonerShallow]`, `[FastClonerReference]`  
+Explicit: `[FastClonerBehavior(CloneBehavior.X)]`
 
-### Customizing Reflection Cloning
+#### Runtime (Reflection only)
 
-Use `FastCloner.FastCloner.SetTypeBehavior<T>` to configure how specific types are cloned globally.
+Configure type behavior dynamically. Runtime settings are checked **before** attributes:
 
 ```csharp
-FastCloner.FastCloner.SetTypeBehavior<MySingletonService>(CloneBehavior.Skip);
+FastCloner.FastCloner.SetTypeBehavior<MySingleton>(CloneBehavior.Reference);
+FastCloner.FastCloner.ClearTypeBehavior<MySingleton>();    // Reset one
+FastCloner.FastCloner.ClearAllTypeBehaviors();             // Reset all
 ```
 
-Available behaviors:
-*   `Clone`: Deep recursive copy.
-*   `Reference`: Return the original instance.
-*   `Shallow`: Top-level `MemberwiseClone`.
-*   `Skip`: Return `default`, skip cloning.
+> **Note**: Changing runtime behavior invalidates the cache. Try to configure once at startup, or use compile-time attributes when possible.
 
-To reset a behavior:
-```csharp
-FastCloner.FastCloner.ClearTypeBehavior<MySingletonService>();
-FastCloner.FastCloner.ClearAllTypeBehaviors();
-```
+#### Precedence (highest to lowest)
 
->*Note: Changing type behavior at runtime automatically invalidates the internal cache, which may temporarily impact performance. Try to configure behaviors once, at application startup.*
+1. Runtime `SetTypeBehavior<T>()` 
+2. Member-level attribute
+3. Type-level attribute on member's type
+4. Default behavior
 
-Cache can be invalidated to reduce the memory footprint, if needed:
+### Cache Management
 
 ```csharp
-FastCloner.FastCloner.ClearCache();
+FastCloner.FastCloner.ClearCache();  // Free memory from reflection cache
 ```
 
+
 ### Generic Classes and Abstract Types
 
 The source generator automatically discovers which concrete types your generic classes and abstract hierarchies are used with:

src/FastCloner.SourceGenerator/ImplicitTypeAnalyzer.cs

@@ -104,7 +104,7 @@ bool TryHandleComponent(ITypeSymbol componentType, out MemberModel? componentMem
                             HasGetter: true,
                             HasSetter: true,
                             SetterIsAccessible: true,
-                            IsShallowClone: false
+                            MemberBehavior: MemberCloneBehavior.Clone
                         );
                         return true;
                     }

src/FastCloner.SourceGenerator/MemberCollector.cs

@@ -3,6 +3,18 @@
 
 namespace FastCloner.SourceGenerator;
 
+/// <summary>
+/// Represents the member-level clone behavior as determined by attributes.
+/// Mirrors FastCloner.Code.CloneBehavior enum values.
+/// </summary>
+internal enum MemberCloneBehavior
+{
+    Clone = 0,      // Default: deep clone
+    Reference = 1,  // Copy reference directly
+    Shallow = 2,    // MemberwiseClone (treated same as Reference for members)
+    Ignore = 3      // Skip, set to default
+}
+
 internal record struct MemberAnalysis(MemberModel Model, ITypeSymbol Type);
 
 internal static class MemberCollector
@@ -46,10 +58,10 @@ public static List<MemberAnalysis> GetMembers(
                         // Include property if it has an accessible setter OR it's a getter-only populatable collection
                         if (hasAccessibleSetter || isPopulatableCollection)
                         {
-                            if (!HasIgnoreAttribute(property, compilation))
+                            MemberCloneBehavior behavior = GetMemberBehavior(property, compilation);
+                            if (behavior != MemberCloneBehavior.Ignore)
                             {
-                                bool isShallow = HasShallowAttribute(property, compilation);
-                                members.Add(new MemberAnalysis(MemberModel.Create(property, nullabilityEnabled, compilation, isShallow), property.Type));
+                                members.Add(new MemberAnalysis(MemberModel.Create(property, nullabilityEnabled, compilation, behavior), property.Type));
                             }
                         }
                     }
@@ -58,10 +70,10 @@ public static List<MemberAnalysis> GetMembers(
                 {
                     if (field.IsConst) continue; // Skip const fields
 
-                    if (!HasIgnoreAttribute(field, compilation))
+                    MemberCloneBehavior behavior = GetMemberBehavior(field, compilation);
+                    if (behavior != MemberCloneBehavior.Ignore)
                     {
-                        bool isShallow = HasShallowAttribute(field, compilation);
-                        members.Add(new MemberAnalysis(MemberModel.Create(field, nullabilityEnabled, compilation, isShallow), field.Type));
+                        members.Add(new MemberAnalysis(MemberModel.Create(field, nullabilityEnabled, compilation, behavior), field.Type));
                     }
                 }
             }
@@ -138,46 +150,136 @@ private static bool IsPopulatableCollectionType(ITypeSymbol type)
         return false;
     }
 
-    private static bool HasIgnoreAttribute(ISymbol member, Compilation compilation)
+    /// <summary>
+    /// Gets the clone behavior for a type by checking for FastClonerBehaviorAttribute on the type definition.
+    /// </summary>
+    private static MemberCloneBehavior? GetTypeBehavior(ITypeSymbol type, Compilation compilation)
     {
+        INamedTypeSymbol? behaviorAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerBehaviorAttribute");
         INamedTypeSymbol? ignoreAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerIgnoreAttribute");
-        INamedTypeSymbol? nonSerializedAttribute = compilation.GetTypeByMetadataName("System.NonSerializedAttribute");
+        INamedTypeSymbol? shallowAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerShallowAttribute");
+        INamedTypeSymbol? referenceAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerReferenceAttribute");
 
-        foreach (AttributeData? attr in member.GetAttributes())
+        foreach (AttributeData attr in type.GetAttributes())
         {
-            if (SymbolEqualityComparer.Default.Equals(attr.AttributeClass, ignoreAttribute))
+            INamedTypeSymbol? attrClass = attr.AttributeClass;
+            if (attrClass == null)
+                continue;
+
+            if (ignoreAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, ignoreAttribute))
             {
-                // Check if Ignored property is true (default is true)
-                if (attr.ConstructorArguments.Length == 0)
-                    return true;
-                if (attr.ConstructorArguments.Length > 0 && attr.ConstructorArguments[0].Value is bool ignored)
-                    return ignored;
-                return true;
+                return attr.ConstructorArguments.Length switch
+                {
+                    0 => MemberCloneBehavior.Ignore,
+                    > 0 when attr.ConstructorArguments[0].Value is bool ignored => ignored ? MemberCloneBehavior.Ignore : null,
+                    _ => MemberCloneBehavior.Ignore
+                };
+            }
+
+            if (shallowAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, shallowAttribute))
+            {
+                return MemberCloneBehavior.Shallow;
             }
 
-            if (SymbolEqualityComparer.Default.Equals(attr.AttributeClass, nonSerializedAttribute))
+            if (referenceAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, referenceAttribute))
             {
-                return true;
+                return MemberCloneBehavior.Reference;
+            }
+
+            if (behaviorAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, behaviorAttribute))
+            {
+                if (attr.ConstructorArguments.Length > 0 && attr.ConstructorArguments[0].Value is int behaviorInt)
+                {
+                    return (MemberCloneBehavior)behaviorInt;
+                }
             }
         }
 
-        return false;
+        return null;
     }
 
-    private static bool HasShallowAttribute(ISymbol member, Compilation compilation)
+    /// <summary>
+    /// Gets the clone behavior for a member by checking:
+    /// 1. Member-level FastClonerBehaviorAttribute (highest priority)
+    /// 2. [NonSerialized] attribute (treat as Ignore)
+    /// 3. Type-level FastClonerBehaviorAttribute on the member's type (lowest priority)
+    /// </summary>
+    private static MemberCloneBehavior GetMemberBehavior(ISymbol member, ITypeSymbol memberType, Compilation compilation)
     {
+        // Get all relevant attribute types
+        INamedTypeSymbol? behaviorAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerBehaviorAttribute");
+        INamedTypeSymbol? ignoreAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerIgnoreAttribute");
         INamedTypeSymbol? shallowAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerShallowAttribute");
-        if (shallowAttribute == null)
-            return false;
+        INamedTypeSymbol? referenceAttribute = compilation.GetTypeByMetadataName("FastCloner.Code.FastClonerReferenceAttribute");
+        INamedTypeSymbol? nonSerializedAttribute = compilation.GetTypeByMetadataName("System.NonSerializedAttribute");
 
-        foreach (AttributeData? attr in member.GetAttributes())
+        // 1. Check for member-level attributes first (highest priority)
+        foreach (AttributeData attr in member.GetAttributes())
         {
-            if (SymbolEqualityComparer.Default.Equals(attr.AttributeClass, shallowAttribute))
+            INamedTypeSymbol? attrClass = attr.AttributeClass;
+            if (attrClass == null)
+                continue;
+
+            // Check for specific derived attributes first (shorthand attributes)
+            if (ignoreAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, ignoreAttribute))
             {
-                return true;
+                return attr.ConstructorArguments.Length switch
+                {
+                    // Check if Ignored property is true (default is true)
+                    0 => MemberCloneBehavior.Ignore,
+                    > 0 when attr.ConstructorArguments[0].Value is bool ignored => ignored ? MemberCloneBehavior.Ignore : MemberCloneBehavior.Clone,
+                    _ => MemberCloneBehavior.Ignore
+                };
+            }
+
+            if (shallowAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, shallowAttribute))
+            {
+                return MemberCloneBehavior.Shallow;
+            }
+
+            if (referenceAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, referenceAttribute))
+            {
+                return MemberCloneBehavior.Reference;
+            }
+
+            // Check for base FastClonerBehaviorAttribute with explicit behavior parameter
+            if (behaviorAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, behaviorAttribute))
+            {
+                if (attr.ConstructorArguments.Length > 0 && attr.ConstructorArguments[0].Value is int behaviorInt)
+                {
+                    return (MemberCloneBehavior)behaviorInt;
+                }
+            }
+
+            // Check for [NonSerialized] - treat as Ignore
+            if (nonSerializedAttribute != null && SymbolEqualityComparer.Default.Equals(attrClass, nonSerializedAttribute))
+            {
+                return MemberCloneBehavior.Ignore;
             }
         }
 
-        return false;
+        // 2. Check for type-level attribute on the member's type
+        MemberCloneBehavior? typeBehavior = GetTypeBehavior(memberType, compilation);
+        
+        return typeBehavior ?? MemberCloneBehavior.Clone;
+    }
+
+    /// <summary>
+    /// Gets the clone behavior for a member (overload for backward compatibility).
+    /// </summary>
+    private static MemberCloneBehavior GetMemberBehavior(ISymbol member, Compilation compilation)
+    {
+        ITypeSymbol? memberType = member switch
+        {
+            IFieldSymbol f => f.Type,
+            IPropertySymbol p => p.Type,
+            IEventSymbol e => e.Type,
+            _ => null
+        };
+
+        return memberType != null 
+            ? GetMemberBehavior(member, memberType, compilation) 
+            : MemberCloneBehavior.Clone;
     }
 }
+

src/FastCloner.SourceGenerator/MemberModel.cs

@@ -83,10 +83,19 @@ internal readonly record struct MemberModel(
     bool HasGetter,                  // Whether the property has a getter
     bool HasSetter,                  // Whether the property has a setter (regular, not init-only)
     bool SetterIsAccessible,         // Whether the setter is publicly accessible (not private/protected)
-    bool IsShallowClone              // Whether the member should be shallow cloned (has [FastClonerShallow] attribute)
+    MemberCloneBehavior MemberBehavior  // The clone behavior for this member (Clone, Reference, Shallow, Ignore)
 ) : IEquatable<MemberModel>
 {
-    public static MemberModel Create(IPropertySymbol property, bool nullabilityEnabled, Compilation compilation, bool isShallowClone = false)
+    /// <summary>
+    /// Returns true if the member should have its reference copied directly without deep cloning.
+    /// This applies to both Shallow and Reference behaviors.
+    /// </summary>
+    public bool ShouldCopyReference => MemberBehavior == MemberCloneBehavior.Shallow || MemberBehavior == MemberCloneBehavior.Reference;
+    
+    // Legacy property for backward compatibility
+    public bool IsShallowClone => ShouldCopyReference;
+
+    public static MemberModel Create(IPropertySymbol property, bool nullabilityEnabled, Compilation compilation, MemberCloneBehavior memberBehavior = MemberCloneBehavior.Clone)
     {
         (MemberTypeKind typeKind, string? elementName, string? keyName, string? valueName, bool elementSafe, bool elementClonable, bool keySafe, bool keyClonable, bool valSafe, bool valClonable, bool requiresFastCloner, CollectionKind collectionKind, string? concreteType, int arrayRank) 
             = AnalyzeType(property.Type, compilation);
@@ -132,10 +141,10 @@ public static MemberModel Create(IPropertySymbol property, bool nullabilityEnabl
             hasGetter,
             hasSetter,
             setterIsAccessible,
-            isShallowClone);
+            memberBehavior);
     }
 
-    public static MemberModel Create(IFieldSymbol field, bool nullabilityEnabled, Compilation compilation, bool isShallowClone = false)
+    public static MemberModel Create(IFieldSymbol field, bool nullabilityEnabled, Compilation compilation, MemberCloneBehavior memberBehavior = MemberCloneBehavior.Clone)
     {
         (MemberTypeKind typeKind, string? elementName, string? keyName, string? valueName, bool elementSafe, bool elementClonable, bool keySafe, bool keyClonable, bool valSafe, bool valClonable, bool requiresFastCloner, CollectionKind collectionKind, string? concreteType, int arrayRank) 
             = AnalyzeType(field.Type, compilation);
@@ -175,7 +184,7 @@ public static MemberModel Create(IFieldSymbol field, bool nullabilityEnabled, Co
             hasGetter,
             hasSetter,
             setterIsAccessible,
-            isShallowClone);
+            memberBehavior);
     }
 
     private static (MemberTypeKind kind, string? elem, string? key, string? val, bool elemSafe, bool elemClon, bool keySafe, bool keyClon, bool valSafe, bool valClon, bool requiresFastCloner, CollectionKind collKind, string? concreteType, int arrayRank) 

src/FastCloner.SourceGenerator/NestedTypeCollector.cs

@@ -84,7 +84,7 @@ public static void Collect(
                     true,  // HasGetter - helper methods always have access
                     true,  // HasSetter - helper methods always have access
                     true,  // SetterIsAccessible - helper methods always have access
-                    false  // IsShallowClone - helper methods are never shallow
+                    MemberCloneBehavior.Clone  // MemberBehavior - helper methods use default cloning
                  );
 
                  if (!nestedTypes.ContainsKey(model.TypeFullName))
@@ -142,7 +142,7 @@ public static void Collect(
                     true,  // HasGetter - helper methods always have access
                     true,  // HasSetter - helper methods always have access
                     true,  // SetterIsAccessible - helper methods always have access
-                    false  // IsShallowClone - helper methods are never shallow
+                    MemberCloneBehavior.Clone  // MemberBehavior - helper methods use default cloning
                  );
 
                  if (!nestedTypes.ContainsKey(model.TypeFullName))