sharplib/lib/CodeGen.cs

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  S H A R P L I B
//
/// // (c) 2003..2025

using System;
using System.IO;
using System.Xml;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Collections.Immutable;
using System.Collections.Concurrent;
using System.Collections.Immutable;

namespace ser;

public record CodeGenConfig : io.Recorded<CodeGenConfig>
{
    // Whitelists (if needed, otherwise rely on attributes/defaults)
    public ImmutableDictionary<string, ImmutableList<string>> WLProps { get; init; } = ImmutableDictionary<string, ImmutableList<string>>.Empty;
    public ImmutableDictionary<string, ImmutableList<string>> WLFields { get; init; } = ImmutableDictionary<string, ImmutableList<string>>.Empty;

    // Default member types to process
    public ser.Types TypesDefault { get; init; } = ser.Types.Fields | ser.Types.Props;

    // How to handle backing fields (might be less relevant for code gen)
    public BackingFieldNaming Naming { get; init; } = BackingFieldNaming.Regular;

    public static CodeGenConfig Default { get; } = new CodeGenConfig();
}

public record GenMemberMeta(
        MemberInfo Info,
        Type Type,
        string Name, // Name for code generation (usually original)
        bool IsPrimitive,
        bool IsCollection,
        Type? CollectionElementType,
        bool HasDo,
        bool HasDont
);

public record TypeStructureInfo(
    Type Type,
    List<GenMemberMeta> Members,
    bool IsValueType,
    bool IsCollection
);

public class TypeStructureAnalyzer
{
    private readonly ConcurrentDictionary<Type, TypeStructureInfo> _cache = new();
    private readonly CodeGenConfig _cfg;

    public TypeStructureAnalyzer( CodeGenConfig cfg ) => _cfg = cfg;

    public TypeStructureInfo Get( Type type ) => _cache.GetOrAdd( type, BuildTypeInfo );

    private TypeStructureInfo BuildTypeInfo( Type type )
    {
        var members = new List<GenMemberMeta>();
        var typesTodo = type.GetCustomAttribute<ser.Ser>( true )?.Types ?? _cfg.TypesDefault;
        bool doFields = typesTodo.HasFlag( ser.Types.Fields );
        bool doProps = typesTodo.HasFlag( ser.Types.Props );

        // Track processed names to avoid duplicates (e.g., field + prop)
        var processedNames = new HashSet<string>();

        // Process Properties First (often preferred interface)
        if( doProps )
        {
            foreach( var pi in refl.GetAllProperties( type ) )
            {
                if( ProcessMember( pi, false, false, new HashSet<string>(), false, members ) )
                {
                    processedNames.Add( pi.Name );
                }
            }
        }

        // Process Fields, avoiding those already covered by properties
        if( doFields )
        {
            foreach( var fi in refl.GetAllFields( type ) )
            {
                var (isBacking, propName) = IsBackingField( fi );
                string nameToTest = isBacking ? propName : fi.Name;

                if( !processedNames.Contains( nameToTest ) )
                {
                    if( ProcessMember( fi, false, false, new HashSet<string>(), false, members ) )
                    {
                        processedNames.Add( nameToTest );
                    }
                }
            }
        }

        return new TypeStructureInfo(
            type,
            members,
            type.IsValueType,
            typeof( IEnumerable ).IsAssignableFrom( type ) && type != typeof( string )
        );
    }

    private bool ProcessMember( MemberInfo mi, bool filter, bool doImpls, HashSet<string> whitelist, bool isImm, List<GenMemberMeta> members )
    {
        var (hasDo, hasDont, propName) = GetMemberAttributes( mi, out var actualMiForAtts );

        if( hasDont )
            return false;
        if( mi.GetCustomAttribute<NonSerializedAttribute>( true ) != null )
            return false;
        if( mi.Name.Contains( "k__BackingField" ) && !propName.Any() )
            return false; // Skip if backing but no prop found

        string name = string.IsNullOrEmpty( propName ) ? mi.Name : propName;

        // Add filtering logic if needed (based on whitelist, etc.)

        var type = ( mi is FieldInfo fi ) ? fi.FieldType : ( (PropertyInfo)mi ).PropertyType;
        bool isCollection = typeof( IEnumerable ).IsAssignableFrom( type ) && type != typeof( string );
        Type? elementType = isCollection ? GetElementType( type ) : null;
        bool isPrimitive = Type.GetTypeCode( type ) != TypeCode.Object && !isCollection;

        members.Add( new GenMemberMeta(
            mi, type, name, isPrimitive, isCollection, elementType, hasDo, hasDont
        ) );
        return true;
    }

    private (bool, string) IsBackingField( FieldInfo fi )
    {
        if( fi.Name.StartsWith( "<" ) && fi.Name.EndsWith( "BackingField" ) )
        {
            var gtIndex = fi.Name.IndexOf( '>' );
            if( gtIndex > 1 )
            {
                return (true, fi.Name.Substring( 1, gtIndex - 1 ));
            }
        }
        return (false, "");
    }

    private (bool hasDo, bool hasDont, string propName) GetMemberAttributes( MemberInfo mi, out MemberInfo actualMi )
    {
        actualMi = mi;
        string propName = "";
        if( mi is FieldInfo fi && IsBackingField( fi ).Item1 )
        {
            propName = IsBackingField( fi ).Item2;
            var propInfo = mi.DeclaringType?.GetProperty( propName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
            if( propInfo != null )
                actualMi = propInfo;
        }
        else if( mi is PropertyInfo )
        {
            propName = mi.Name;
        }

        return (
            actualMi.GetCustomAttribute<ser.Do>() != null,
            actualMi.GetCustomAttribute<ser.Dont>() != null,
            propName
        );
    }

    private Type GetElementType( Type collectionType )
    {
        if( collectionType.IsArray )
            return collectionType.GetElementType()!;
        if( collectionType.IsGenericType )
            return collectionType.GetGenericArguments().Last(); // Usually last (e.g., List<T>, Dict<K,V>)
        return typeof( object ); // Fallback
    }

    // Add GetFilters and FilterField if needed, or simplify as above
}