feat: add MapDerivedType for existing target type mapping

src/Riok.Mapperly/Descriptors/MappingBuilders/DerivedTypeMappingBuilder.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Configuration;
 using Riok.Mapperly.Descriptors.Mappings;
+using Riok.Mapperly.Descriptors.Mappings.ExistingTarget;
 using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
 
@@ -19,6 +20,15 @@ public static class DerivedTypeMappingBuilder
             : new DerivedTypeSwitchMapping(ctx.Source, ctx.Target, derivedTypeMappings);
     }
 
+    public static IExistingTargetMapping? TryBuildExistingTargetMapping(MappingBuilderContext ctx)
+    {
+        var derivedTypeMappings = TryBuildExistingTargetContainedMappings(ctx);
+        if (derivedTypeMappings == null)
+            return null;
+
+        return new DerivedExistingTargetTypeMapping(ctx.Source, ctx.Target, derivedTypeMappings);
+    }
+
     public static IReadOnlyCollection<INewInstanceMapping>? TryBuildContainedMappings(
         MappingBuilderContext ctx,
         bool duplicatedSourceTypesAllowed = false
@@ -29,6 +39,16 @@ public static class DerivedTypeMappingBuilder
             : BuildContainedMappings(ctx, ctx.Configuration.DerivedTypes, duplicatedSourceTypesAllowed);
     }
 
+    public static IReadOnlyCollection<IExistingTargetMapping>? TryBuildExistingTargetContainedMappings(
+        MappingBuilderContext ctx,
+        bool duplicatedSourceTypesAllowed = false
+    )
+    {
+        return ctx.Configuration.DerivedTypes.Count == 0
+            ? null
+            : BuildExistingTargetContainedMappings(ctx, ctx.Configuration.DerivedTypes, duplicatedSourceTypesAllowed);
+    }
+
     private static IReadOnlyCollection<INewInstanceMapping> BuildContainedMappings(
         MappingBuilderContext ctx,
         IReadOnlyCollection<DerivedTypeMappingConfiguration> configs,
@@ -83,4 +103,59 @@ bool duplicatedSourceTypesAllowed
 
         return derivedTypeMappings;
     }
+
+    private static IReadOnlyCollection<IExistingTargetMapping> BuildExistingTargetContainedMappings(
+        MappingBuilderContext ctx,
+        IReadOnlyCollection<DerivedTypeMappingConfiguration> configs,
+        bool duplicatedSourceTypesAllowed
+    )
+    {
+        var derivedTypeMappingSourceTypes = new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default);
+        var derivedTypeMappings = new List<IExistingTargetMapping>(configs.Count);
+        Func<ITypeSymbol, bool> isAssignableToSource = ctx.Source is ITypeParameterSymbol sourceTypeParameter
+            ? t => ctx.SymbolAccessor.DoesTypeSatisfyTypeParameterConstraints(sourceTypeParameter, t, ctx.Source.NullableAnnotation)
+            : t => ctx.SymbolAccessor.HasImplicitConversion(t, ctx.Source);
+        Func<ITypeSymbol, bool> isAssignableToTarget = ctx.Target is ITypeParameterSymbol targetTypeParameter
+            ? t => ctx.SymbolAccessor.DoesTypeSatisfyTypeParameterConstraints(targetTypeParameter, t, ctx.Target.NullableAnnotation)
+            : t => ctx.SymbolAccessor.HasImplicitConversion(t, ctx.Target);
+
+        foreach (var config in configs)
+        {
+            // set types non-nullable as they can never be null when type-switching.
+            var sourceType = config.SourceType.NonNullable();
+            if (!duplicatedSourceTypesAllowed && !derivedTypeMappingSourceTypes.Add(sourceType))
+            {
+                ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedSourceTypeDuplicated, sourceType);
+                continue;
+            }
+
+            if (!isAssignableToSource(sourceType))
+            {
+                ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedSourceTypeIsNotAssignableToParameterType, sourceType, ctx.Source);
+                continue;
+            }
+
+            var targetType = config.TargetType.NonNullable();
+            if (!isAssignableToTarget(targetType))
+            {
+                ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedTargetTypeIsNotAssignableToReturnType, targetType, ctx.Target);
+                continue;
+            }
+
+            var mapping = ctx.FindOrBuildExistingTargetMapping(
+                sourceType,
+                targetType,
+                MappingBuildingOptions.KeepUserSymbol | MappingBuildingOptions.MarkAsReusable | MappingBuildingOptions.ClearDerivedTypes
+            );
+            if (mapping == null)
+            {
+                ctx.ReportDiagnostic(DiagnosticDescriptors.CouldNotCreateMapping, sourceType, targetType);
+                continue;
+            }
+
+            derivedTypeMappings.Add(mapping);
+        }
+
+        return derivedTypeMappings;
+    }
 }

src/Riok.Mapperly/Descriptors/MappingBuilders/ExistingTargetMappingBuilder.cs

@@ -10,6 +10,7 @@ public class ExistingTargetMappingBuilder
     private static readonly IReadOnlyCollection<BuildExistingTargetMapping> _builders = new BuildExistingTargetMapping[]
     {
         NullableMappingBuilder.TryBuildExistingTargetMapping,
+        DerivedTypeMappingBuilder.TryBuildExistingTargetMapping,
         DictionaryMappingBuilder.TryBuildExistingTargetMapping,
         SpanMappingBuilder.TryBuildExistingTargetMapping,
         MemoryMappingBuilder.TryBuildExistingTargetMapping,

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

@@ -0,0 +1,83 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Descriptors.Mappings.ExistingTarget;
+using Riok.Mapperly.Emit.Syntax;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using static Riok.Mapperly.Emit.Syntax.SyntaxFactoryHelper;
+
+namespace Riok.Mapperly.Descriptors.Mappings;
+
+/// <summary>
+/// A derived type mapping maps one base type or interface to another
+/// by implementing a if with instance checks over known types and performs the provided mapping for each type.
+/// </summary>
+public class DerivedExistingTargetTypeMapping : ExistingTargetMapping
+{
+    private const string SourceName = "source";
+    private const string TargetName = "target";
+    private const string GetTypeMethodName = nameof(GetType);
+    private readonly IReadOnlyCollection<IExistingTargetMapping> _existingTargetTypeMappings;
+
+    public DerivedExistingTargetTypeMapping(
+        ITypeSymbol sourceType,
+        ITypeSymbol targetType,
+        IReadOnlyCollection<IExistingTargetMapping> existingTargetTypeMappings
+    )
+        : base(sourceType, targetType)
+    {
+        _existingTargetTypeMappings = existingTargetTypeMappings;
+    }
+
+    public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx, ExpressionSyntax target)
+    {
+        var sourceExpression = TupleExpression(CommaSeparatedList(Argument(ctx.Source), Argument(target)));
+        var sections = _existingTargetTypeMappings.Select(x => BuildSwitchSection(ctx, x)).Append(BuildDefaultSwitchSection(ctx));
+
+        yield return ctx.SyntaxFactory.SwitchStatement(sourceExpression, List(sections)).AddLeadingLineFeed(ctx.SyntaxFactory.Indentation);
+    }
+
+    private SwitchSectionSyntax BuildSwitchSection(TypeMappingBuildContext ctx, IExistingTargetMapping mapping)
+    {
+        // MapToB(source, target);
+        var (sectionCtx, sourceVariableName) = ctx.WithNewScopedSource(SourceName);
+        var targetVariableName = sectionCtx.NameBuilder.New(TargetName);
+        sectionCtx = sectionCtx.AddIndentation();
+
+        var positionalTypeMatch = PositionalPatternClause(
+            CommaSeparatedList(
+                Subpattern(DeclarationPattern(mapping.SourceType, sourceVariableName)),
+                Subpattern(DeclarationPattern(mapping.TargetType, targetVariableName))
+            )
+        );
+
+        var pattern = RecursivePattern().WithPositionalPatternClause(positionalTypeMatch);
+        var caseLabel = CasePatternSwitchLabel(pattern).AddLeadingLineFeed(sectionCtx.SyntaxFactory.Indentation);
+
+        var target = IdentifierName(targetVariableName);
+
+        var statementContext = sectionCtx.AddIndentation();
+        var statements = List(
+            mapping.Build(statementContext, target).Append(BreakStatement().AddLeadingLineFeed(statementContext.SyntaxFactory.Indentation))
+        );
+        var section = SwitchSection().WithLabels(SingletonList<SwitchLabelSyntax>(caseLabel)).WithStatements(statements);
+
+        return section;
+    }
+
+    private SwitchSectionSyntax BuildDefaultSwitchSection(TypeMappingBuildContext ctx)
+    {
+        // default:
+        var defaultCaseLabel = DefaultSwitchLabel().AddLeadingLineFeed(ctx.SyntaxFactory.Indentation + 1);
+
+        // throw new ArgumentException(msg, nameof(ctx.Source)),
+        var sourceType = Invocation(MemberAccess(ctx.Source, GetTypeMethodName));
+        var throwExpression = ThrowArgumentExpression(
+                InterpolatedString($"Cannot map {sourceType} to {TargetType.ToDisplayString()} as there is no known derived type mapping"),
+                ctx.Source
+            )
+            .AddLeadingLineFeed(ctx.SyntaxFactory.Indentation + 2);
+
+        var stat = new StatementSyntax[] { ExpressionStatement(throwExpression) };
+        return SwitchSection().WithLabels(SingletonList<SwitchLabelSyntax>(defaultCaseLabel)).WithStatements(List(stat));
+    }
+}

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

@@ -63,6 +63,14 @@ SyntaxFactoryHelper syntaxFactory
         return (ctx, scopedSourceName);
     }
 
+    public (TypeMappingBuildContext Context, string SourceName) WithNewScopedSource(string sourceName)
+    {
+        var scopedNameBuilder = NameBuilder.NewScope();
+        var scopedSourceName = scopedNameBuilder.New(sourceName);
+        var ctx = new TypeMappingBuildContext(IdentifierName(scopedSourceName), ReferenceHandler, scopedNameBuilder, SyntaxFactory);
+        return (ctx, scopedSourceName);
+    }
+
     public (TypeMappingBuildContext Context, string SourceName) WithNewSource(string sourceName = DefaultSourceName)
     {
         var scopedSourceName = NameBuilder.New(sourceName);

src/Riok.Mapperly/Emit/Syntax/SyntaxFactoryHelper.Pattern.cs

@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Riok.Mapperly.Helpers;
@@ -16,6 +17,12 @@ public static PatternSyntax OrPattern(IEnumerable<ExpressionSyntax?> values) =>
     public static IsPatternExpressionSyntax IsPattern(ExpressionSyntax expression, PatternSyntax pattern) =>
         IsPatternExpression(expression, SpacedToken(SyntaxKind.IsKeyword), pattern);
 
+    public static DeclarationPatternSyntax DeclarationPattern(ITypeSymbol type, string designation) =>
+        SyntaxFactory.DeclarationPattern(
+            FullyQualifiedIdentifier(type).AddTrailingSpace(),
+            SingleVariableDesignation(Identifier(designation))
+        );
+
     private static BinaryPatternSyntax BinaryPattern(SyntaxKind kind, PatternSyntax left, PatternSyntax right)
     {
         var binaryPattern = SyntaxFactory.BinaryPattern(kind, left, right);

src/Riok.Mapperly/Emit/Syntax/SyntaxFactoryHelper.Switch.cs

@@ -23,4 +23,21 @@ public static SwitchExpressionArmSyntax SwitchArm(PatternSyntax pattern, Express
     }
 
     public static WhenClauseSyntax SwitchWhen(ExpressionSyntax condition) => WhenClause(SpacedToken(SyntaxKind.WhenKeyword), condition);
+
+    public SwitchStatementSyntax SwitchStatement(ExpressionSyntax governingExpression, IEnumerable<SwitchSectionSyntax> sections)
+    {
+        return SyntaxFactory.SwitchStatement(
+            default,
+            TrailingSpacedToken(SyntaxKind.SwitchKeyword),
+            Token(SyntaxKind.None),
+            governingExpression,
+            Token(SyntaxKind.None),
+            LeadingLineFeedToken(SyntaxKind.OpenBraceToken),
+            List(sections),
+            LeadingLineFeedToken(SyntaxKind.CloseBraceToken)
+        );
+    }
+
+    public static CasePatternSwitchLabelSyntax CasePatternSwitchLabel(PatternSyntax pattern) =>
+        SyntaxFactory.CasePatternSwitchLabel(TrailingSpacedToken(SyntaxKind.CaseKeyword), pattern, null, Token(SyntaxKind.ColonToken));
 }