feat: add MaxDepth for recursive queries

src/Riok.Mapperly.Abstractions/MapperAttribute.cs

@@ -97,4 +97,9 @@ public class MapperAttribute : Attribute
     /// Determines the access level of members that Mapperly will map.
     /// </summary>
     public MemberVisibility IncludedMembers { get; set; } = MemberVisibility.AllAccessible;
+
+    /// <summary>
+    /// Defines the maximum recursive depth that an IQueryable mapping will use.
+    /// </summary>
+    public int MaxRecursiveDepth { get; set; } = 8;
 }

src/Riok.Mapperly.Abstractions/MapperMaxRecursiveDepthAttribute.cs

@@ -0,0 +1,22 @@
+namespace Riok.Mapperly.Abstractions;
+
+/// <summary>
+/// Defines the maximum recursive depth that an IQueryable mapping will use.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class MapperMaxRecursiveDepthAttribute : Attribute
+{
+    /// <summary>
+    /// Defines the maximum recursive depth that an IQueryable mapping will use.
+    /// </summary>
+    /// <param name="maxRecursiveDepth">The maximum recursive depth used when mapping IQueryable members.</param>
+    public MapperMaxRecursiveDepthAttribute(int maxRecursiveDepth)
+    {
+        MaxRecursiveDepth = maxRecursiveDepth;
+    }
+
+    /// <summary>
+    /// The maximum recursive depth used when mapping IQueryable members.
+    /// </summary>
+    public int MaxRecursiveDepth { get; }
+}

src/Riok.Mapperly/Configuration/MapperConfiguration.cs

@@ -103,4 +103,9 @@ public record MapperConfiguration
     /// Determines the access level of members that Mapperly will map.
     /// </summary>
     public MemberVisibility? IncludedMembers { get; init; }
+
+    /// <summary>
+    /// Defines the maximum recursive depth that an IQueryable mapping will use.
+    /// </summary>
+    public int? MaxRecursiveDepth { get; init; }
 }

src/Riok.Mapperly/Configuration/MapperConfigurationMerger.cs

@@ -54,6 +54,9 @@ public static MapperAttribute Merge(MapperConfiguration mapperConfiguration, Map
         mapper.IncludedMembers =
             mapperConfiguration.IncludedMembers ?? defaultMapperConfiguration.IncludedMembers ?? mapper.IncludedMembers;
 
+        mapper.MaxRecursiveDepth =
+            mapperConfiguration.MaxRecursiveDepth ?? defaultMapperConfiguration.MaxRecursiveDepth ?? mapper.MaxRecursiveDepth;
+
         return mapper;
     }
 }

src/Riok.Mapperly/Configuration/MapperConfigurationReader.cs

@@ -33,7 +33,8 @@ MapperConfiguration defaultMapperConfiguration
                 Array.Empty<string>(),
                 Array.Empty<PropertyMappingConfiguration>(),
                 Mapper.IgnoreObsoleteMembersStrategy,
-                Mapper.RequiredMappingStrategy
+                Mapper.RequiredMappingStrategy,
+                Mapper.MaxRecursiveDepth
             ),
             Array.Empty<DerivedTypeMappingConfiguration>()
         );
@@ -79,13 +80,18 @@ private PropertiesMappingConfiguration BuildPropertiesConfig(IMethodSymbol metho
         var requiredMapping = _dataAccessor.Access<MapperRequiredMappingAttribute>(method).FirstOrDefault() is not { } methodWarnUnmapped
             ? _defaultConfiguration.Properties.RequiredMappingStrategy
             : methodWarnUnmapped.RequiredMappingStrategy;
+        var maxRecursiveDepth = _dataAccessor.Access<MapperMaxRecursiveDepthAttribute>(method).FirstOrDefault()
+            is not { } methodMaxRecursiveDepth
+            ? _defaultConfiguration.Properties.MaxRecursiveDepth
+            : methodMaxRecursiveDepth.MaxRecursiveDepth;
 
         return new PropertiesMappingConfiguration(
             ignoredSourceProperties,
             ignoredTargetProperties,
             propertyConfigurations,
             ignoreObsolete,
-            requiredMapping
+            requiredMapping,
+            maxRecursiveDepth
         );
     }
 

src/Riok.Mapperly/Configuration/PropertiesMappingConfiguration.cs

@@ -7,5 +7,6 @@ public record PropertiesMappingConfiguration(
     IReadOnlyCollection<string> IgnoredTargets,
     IReadOnlyCollection<PropertyMappingConfiguration> ExplicitMappings,
     IgnoreObsoleteMembersStrategy IgnoreObsoleteMembersStrategy,
-    RequiredMappingStrategy RequiredMappingStrategy
+    RequiredMappingStrategy RequiredMappingStrategy,
+    int MaxRecursiveDepth
 );

src/Riok.Mapperly/Descriptors/InlineExpressionMappingBuilderContext.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Abstractions;
 using Riok.Mapperly.Descriptors.Mappings;
@@ -14,6 +15,7 @@ public class InlineExpressionMappingBuilderContext : MappingBuilderContext
 {
     private readonly MappingCollection _inlineExpressionMappings;
     private readonly MappingBuilderContext _parentContext;
+    private readonly ImmutableDictionary<TypeMappingKey, int> _parentTypes;
 
     public InlineExpressionMappingBuilderContext(MappingBuilderContext ctx, TypeMappingKey mappingKey)
         : this(ctx, (ctx.FindMapping(mappingKey) as IUserMapping)?.Method, mappingKey) { }
@@ -23,18 +25,24 @@ private InlineExpressionMappingBuilderContext(MappingBuilderContext ctx, IMethod
     {
         _parentContext = ctx;
         _inlineExpressionMappings = new MappingCollection();
+
+        _parentTypes = ctx is InlineExpressionMappingBuilderContext inlineCtx
+            ? inlineCtx._parentTypes
+            : ImmutableDictionary.Create<TypeMappingKey, int>();
     }
 
     private InlineExpressionMappingBuilderContext(
         InlineExpressionMappingBuilderContext ctx,
         IMethodSymbol? userSymbol,
+        ImmutableDictionary<TypeMappingKey, int> parentTypes,
         TypeMappingKey mappingKey,
         bool clearDerivedTypes
     )
         : base(ctx, userSymbol, mappingKey, clearDerivedTypes)
     {
         _parentContext = ctx;
         _inlineExpressionMappings = ctx._inlineExpressionMappings;
+        _parentTypes = parentTypes;
     }
 
     public override bool IsExpression => true;
@@ -56,6 +64,14 @@ conversionType is not MappingConversionType.EnumToString and not MappingConversi
     /// <returns>The <see cref="INewInstanceMapping"/> if a mapping was found or <c>null</c> if none was found.</returns>
     public override INewInstanceMapping? FindMapping(TypeMappingKey mappingKey)
     {
+        // check for recursive loop returning null to prevent a loop or default when recursive limit is reached.
+        if (_parentTypes.TryGetValue(mappingKey, out var count))
+        {
+            return count >= Configuration.Properties.MaxRecursiveDepth
+                ? new DefaultMemberMapping(mappingKey.Source, mappingKey.Target)
+                : null;
+        }
+
         if (_inlineExpressionMappings.Find(mappingKey) is { } mapping)
             return mapping;
 
@@ -139,9 +155,12 @@ protected override MappingBuilderContext ContextForMapping(
         MappingBuildingOptions options
     )
     {
+        var mappingRecursionCount = _parentTypes.GetValueOrDefault(mappingKey);
+        var newParentTypes = _parentTypes.SetItem(mappingKey, mappingRecursionCount + 1);
         return new InlineExpressionMappingBuilderContext(
             this,
             userSymbol,
+            newParentTypes,
             mappingKey,
             options.HasFlag(MappingBuildingOptions.ClearDerivedTypes)
         );

src/Riok.Mapperly/Descriptors/Mappings/DefaultMemberMapping.cs

@@ -0,0 +1,16 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Riok.Mapperly.Emit.Syntax.SyntaxFactoryHelper;
+
+namespace Riok.Mapperly.Descriptors.Mappings;
+
+/// <summary>
+/// Represents a mapping that returns default.
+/// <code>
+/// target = default;
+/// </code>
+/// </summary>
+public class DefaultMemberMapping(ITypeSymbol sourceType, ITypeSymbol targetType) : NewInstanceMapping(sourceType, targetType)
+{
+    public override ExpressionSyntax Build(TypeMappingBuildContext ctx) => DefaultLiteral();
+}

src/Riok.Mapperly/Diagnostics/DiagnosticDescriptors.cs

@@ -482,4 +482,13 @@ public static class DiagnosticDescriptors
         DiagnosticSeverity.Error,
         true
     );
+
+    public static readonly DiagnosticDescriptor MaxRecursiveDepthMustBeZeroOrMore = new DiagnosticDescriptor(
+        "RMG056",
+        $"The value {nameof(MapperAttribute.MaxRecursiveDepth)} cannot be less than zero.",
+        $"The value {nameof(MapperAttribute.MaxRecursiveDepth)} cannot be less than zero.",
+        DiagnosticCategories.Mapper,
+        DiagnosticSeverity.Error,
+        true
+    );
 }

test/Riok.Mapperly.Tests/Mapping/QueryableProjectionLoopTest.cs

@@ -0,0 +1,159 @@
+using Riok.Mapperly.Diagnostics;
+
+namespace Riok.Mapperly.Tests.Mapping;
+
+[UsesVerify]
+public class QueryableProjectionLoopTest
+{
+    [Fact]
+    public Task ReferenceLoopInitProperty()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "System.Linq.IQueryable<A>",
+            "System.Linq.IQueryable<B>",
+            "class A { public A? Parent { get; set; } }",
+            "class B { public B? Parent { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task SetRecursiveDepthForLoop()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "System.Linq.IQueryable<A>",
+            "System.Linq.IQueryable<B>",
+            TestSourceBuilderOptions.Default with
+            {
+                MaxRecursiveDepth = 2
+            },
+            "class A { public A? Parent { get; set; } }",
+            "class B { public B? Parent { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task MethodAttributeSetRecursiveDepthForLoop()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperMaxRecursiveDepth(2)] "
+                + "partial System.Linq.IQueryable<B> Map(System.Linq.IQueryable<A> src);"
+                + "[MapperMaxRecursiveDepth(2)] partial B Map(A src);",
+            "class A { public A? Parent { get; set; } }",
+            "class B { public B? Parent { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task MethodAttributeOverridesClassSetRecursiveDepthForLoop()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapperMaxRecursiveDepth(2)] "
+                + "partial System.Linq.IQueryable<B> Map(System.Linq.IQueryable<A> src);"
+                + "[MapperMaxRecursiveDepth(2)] partial B Map(A src);",
+            TestSourceBuilderOptions.Default with
+            {
+                MaxRecursiveDepth = 4
+            },
+            "class A { public A? Parent { get; set; } }",
+            "class B { public B? Parent { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task AssemblyDefaultShouldWork()
+    {
+        var source = TestSourceBuilder.CSharp(
+            """
+            using Riok.Mapperly.Abstractions;
+
+            [assembly: MapperDefaultsAttribute(MaxRecursiveDepth = 2)]
+            [Mapper()]
+            public partial class MyMapper
+            {
+                private partial B Map(A source);
+            }
+
+            class A { public A? Parent { get; set; } }
+
+            class B { public B? Parent { get; set; } }
+            """
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task AttributeShouldOverrideAssemblyDefault()
+    {
+        var source = TestSourceBuilder.CSharp(
+            """
+            using Riok.Mapperly.Abstractions;
+
+            [assembly: MapperDefaultsAttribute(MaxRecursiveDepth = 2)]
+            [Mapper(MaxRecursiveDepth = 4)]
+            public partial class MyMapper
+            {
+                private partial B Map(A source);
+            }
+
+            class A { public A? Parent { get; set; } }
+
+            class B { public B? Parent { get; set; } }
+            """
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task ReferenceLoopCtor()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "System.Linq.IQueryable<A>",
+            "System.Linq.IQueryable<B>",
+            "class A { public A? Parent { get; set; } }",
+            "class B { public B(B? parent) {} }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public Task IndirectReferenceLoop()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "System.Linq.IQueryable<A>",
+            "System.Linq.IQueryable<B>",
+            "class A { public string StringValue { get; set; } public C Parent { get; set; } }",
+            "class B { public string StringValue { get; set; } public D Parent { get; set; } }",
+            "class C { public A Parent { get; set; } }",
+            "class D {  public B Parent { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
+    [Fact]
+    public void WithReferenceHandlingShouldDiagnostic()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "System.Linq.IQueryable<long>",
+            "System.Linq.IQueryable<int>",
+            TestSourceBuilderOptions.WithReferenceHandling
+        );
+
+        TestHelper
+            .GenerateMapper(source, TestHelperOptions.AllowDiagnostics)
+            .Should()
+            .HaveDiagnostic(DiagnosticDescriptors.QueryableProjectionMappingsDoNotSupportReferenceHandling)
+            .HaveAssertedAllDiagnostics();
+    }
+}