feat: rework generic type matching (#1199)

* support more type parameter constructs for generic mappings such as nested generic types
* emit a new diagnostic (RMG069, warning) for runtime target type mappings which do not match any mapping
* add null arm to runtime target type mappings only if source type is nullable

Author: latonz

src/Riok.Mapperly/AnalyzerReleases.Shipped.md

@@ -153,3 +153,4 @@ RMG065  | Mapper   | Warning  | Cannot configure an object mapping on a queryabl
 RMG066  | Mapper   | Warning  | No members are mapped in an object mapping
 RMG067  | Mapper   | Error    | Invalid usage of the MapPropertyAttribute
 RMG068  | Mapper   | Info     | Cannot inline user implemented queryable expression mapping
+RMG069  | Mapper   | Warning  | Runtime target type or generic type mapping does not match any mappings

src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs

@@ -57,6 +57,7 @@ MapperConfiguration defaultMapperConfiguration
             compilationContext,
             configurationReader,
             _symbolAccessor,
+            new GenericTypeChecker(_symbolAccessor, _types),
             attributeAccessor,
             _unsafeAccessorContext,
             _diagnostics,

src/Riok.Mapperly/Descriptors/Enumerables/CollectionInfoBuilder.cs

@@ -375,7 +375,7 @@ static CollectionType IterateImplementedTypes(ITypeSymbol type, WellKnownTypes t
                 if (typeInfo.GetTypeSymbol(types) is not { } typeSymbol)
                     continue;
 
-                if (type.ImplementsGeneric(typeSymbol, out _))
+                if (type.ExtendsOrImplementsGeneric(typeSymbol, out _))
                 {
                     implementedCollectionTypes |= typeInfo.CollectionType;
                 }

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/RuntimeTargetTypeMappingBodyBuilder.cs

@@ -1,7 +1,7 @@
-using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Descriptors.MappingBuilders;
 using Riok.Mapperly.Descriptors.Mappings;
 using Riok.Mapperly.Descriptors.Mappings.UserMappings;
+using Riok.Mapperly.Diagnostics;
 using Riok.Mapperly.Helpers;
 using Riok.Mapperly.Symbols;
 
@@ -16,42 +16,32 @@ public static void BuildMappingBody(MappingBuilderContext ctx, UserDefinedNewIns
         // as non-nullables are also assignable to nullables.
         var mappings = GetUserMappingCandidates(ctx)
             .Where(x =>
-                DoesTypesSatisfySubstitutionPrinciples(mapping, ctx.SymbolAccessor, x.SourceType.NonNullable(), x.TargetType)
-                && mapping.TypeParameters.DoesTypesSatisfyTypeParameterConstraints(
-                    ctx.SymbolAccessor,
-                    x.SourceType.NonNullable(),
-                    x.TargetType
-                )
+                ctx.GenericTypeChecker.InferAndCheckTypes(
+                    mapping.Method.TypeParameters,
+                    (mapping.SourceType, x.SourceType.NonNullable()),
+                    (mapping.TargetType, x.TargetType)
+                ).Success
             );
 
         BuildMappingBody(ctx, mapping, mappings);
     }
 
-    private static bool DoesTypesSatisfySubstitutionPrinciples(
-        IMapping mapping,
-        SymbolAccessor symbolAccessor,
-        ITypeSymbol sourceType,
-        ITypeSymbol targetType
-    ) =>
-        (mapping.SourceType.TypeKind == TypeKind.TypeParameter || symbolAccessor.HasImplicitConversion(sourceType, mapping.SourceType))
-        && (mapping.TargetType.TypeKind == TypeKind.TypeParameter || symbolAccessor.HasImplicitConversion(targetType, mapping.TargetType));
-
     public static void BuildMappingBody(MappingBuilderContext ctx, UserDefinedNewInstanceRuntimeTargetTypeMapping mapping)
     {
         // source nulls are filtered out by the type switch arms,
         // therefore set source type always to nun-nullable
         // as non-nullables are also assignable to nullables.
         var mappings = GetUserMappingCandidates(ctx)
             .Where(x =>
-                ctx.SymbolAccessor.HasImplicitConversion(x.SourceType.NonNullable(), mapping.SourceType)
-                && ctx.SymbolAccessor.HasImplicitConversion(x.TargetType, mapping.TargetType)
+                ctx.SymbolAccessor.CanAssign(x.SourceType.NonNullable(), mapping.SourceType)
+                && ctx.SymbolAccessor.CanAssign(x.TargetType, mapping.TargetType)
             );
 
         BuildMappingBody(ctx, mapping, mappings);
     }
 
-    private static IEnumerable<ITypeMapping> GetUserMappingCandidates(MappingBuilderContext ctx) =>
-        ctx.UserMappings.Where(x => x is not UserDefinedNewInstanceRuntimeTargetTypeMapping);
+    private static IEnumerable<INewInstanceUserMapping> GetUserMappingCandidates(MappingBuilderContext ctx) =>
+        ctx.UserMappings.Where(x => x is not UserDefinedNewInstanceRuntimeTargetTypeMapping).OfType<INewInstanceUserMapping>();
 
     private static void BuildMappingBody(
         MappingBuilderContext ctx,
@@ -78,7 +68,14 @@ IEnumerable<ITypeMapping> childMappings
             .ThenBy(x => x.TargetType.IsNullable())
             .GroupBy(x => new TypeMappingKey(x, includeNullability: false))
             .Select(x => x.First())
-            .Select(x => new RuntimeTargetTypeMapping(x, ctx.Compilation.HasImplicitConversion(x.TargetType, ctx.Target)));
+            .Select(x => new RuntimeTargetTypeMapping(x, ctx.Compilation.HasImplicitConversion(x.TargetType, ctx.Target)))
+            .ToList();
+
+        if (runtimeTargetTypeMappings.Count == 0)
+        {
+            ctx.ReportDiagnostic(DiagnosticDescriptors.RuntimeTargetTypeMappingNoContentMappings);
+        }
+
         mapping.AddMappings(runtimeTargetTypeMappings);
     }
 }

src/Riok.Mapperly/Descriptors/MappingBuilderContext.cs

@@ -61,7 +61,7 @@ bool ignoreDerivedTypes
 
     public DictionaryInfos? DictionaryInfos => _dictionaryInfos ??= DictionaryInfoBuilder.Build(Types, CollectionInfos);
 
-    protected IMethodSymbol? UserSymbol { get; }
+    public IMethodSymbol? UserSymbol { get; }
 
     public bool HasUserSymbol => UserSymbol != null;
 

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

@@ -61,33 +61,34 @@ bool duplicatedSourceTypesAllowed
     {
         var derivedTypeMappingSourceTypes = new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default);
         var derivedTypeMappings = new List<TMapping>(configs.Count);
-        Func<ITypeSymbol, bool> isAssignableToSource = ctx.Source is ITypeParameterSymbol sourceTypeParameter
-            ? t => ctx.SymbolAccessor.DoesTypeSatisfyTypeParameterConstraints(sourceTypeParameter, t)
-            : t => ctx.SymbolAccessor.HasImplicitConversion(t, ctx.Source);
-        Func<ITypeSymbol, bool> isAssignableToTarget = ctx.Target is ITypeParameterSymbol targetTypeParameter
-            ? t => ctx.SymbolAccessor.DoesTypeSatisfyTypeParameterConstraints(targetTypeParameter, t)
-            : 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();
+            var targetType = config.TargetType.NonNullable();
             if (!duplicatedSourceTypesAllowed && !derivedTypeMappingSourceTypes.Add(sourceType))
             {
                 ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedSourceTypeDuplicated, sourceType);
                 continue;
             }
 
-            if (!isAssignableToSource(sourceType))
+            var typeCheckerResult = ctx.GenericTypeChecker.InferAndCheckTypes(
+                ctx.UserSymbol!.TypeParameters,
+                (ctx.Source, sourceType),
+                (ctx.Target, targetType)
+            );
+            if (!typeCheckerResult.Success)
             {
-                ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedSourceTypeIsNotAssignableToParameterType, sourceType, ctx.Source);
-                continue;
-            }
+                if (ReferenceEquals(sourceType, typeCheckerResult.FailedArgument))
+                {
+                    ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedSourceTypeIsNotAssignableToParameterType, sourceType, ctx.Source);
+                }
+                else
+                {
+                    ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedTargetTypeIsNotAssignableToReturnType, targetType, ctx.Target);
+                }
 
-            var targetType = config.TargetType.NonNullable();
-            if (!isAssignableToTarget(targetType))
-            {
-                ctx.ReportDiagnostic(DiagnosticDescriptors.DerivedTargetTypeIsNotAssignableToReturnType, targetType, ctx.Target);
                 continue;
             }
 

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

@@ -324,7 +324,7 @@ INewInstanceMapping elementMapping
         if (!hasObjectFactory)
         {
             sourceCollectionInfo = BuildCollectionTypeForICollection(ctx, sourceCollectionInfo);
-            ctx.ObjectFactories.TryFindObjectFactory(sourceCollectionInfo.Type, ctx.Target, out objectFactory);
+            ctx.ObjectFactories.TryFindObjectFactory(ctx.Source, ctx.Target, out objectFactory);
             var existingMapping = ctx.BuildDelegatedMapping(sourceCollectionInfo.Type, ctx.Target);
             if (existingMapping != null)
                 return existingMapping;

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

@@ -32,7 +32,6 @@ public abstract class MethodMapping : ITypeMapping
     };
 
     private readonly ITypeSymbol _returnType;
-    private readonly IMethodSymbol? _partialMethodDefinition;
 
     private string? _methodName;
 
@@ -54,11 +53,16 @@ ITypeSymbol targetType
         SourceParameter = sourceParameter;
         IsExtensionMethod = method.IsExtensionMethod;
         ReferenceHandlerParameter = referenceHandlerParameter;
-        _partialMethodDefinition = method;
+        Method = method;
+        MethodDeclarationSyntax = Method?.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax() as MethodDeclarationSyntax;
         _methodName = method.Name;
         _returnType = method.ReturnsVoid ? method.ReturnType : targetType;
     }
 
+    protected IMethodSymbol? Method { get; }
+
+    protected MethodDeclarationSyntax? MethodDeclarationSyntax { get; }
+
     protected bool IsExtensionMethod { get; }
 
     protected string MethodName => _methodName ?? throw new InvalidOperationException();
@@ -117,11 +121,11 @@ protected virtual ParameterListSyntax BuildParameterList() =>
 
     private IEnumerable<SyntaxToken> BuildModifiers(bool isStatic)
     {
-        // if a syntax is referenced it is the implementation part of partial method definition
-        // then copy all modifiers otherwise only set private and optionally static
-        if (_partialMethodDefinition?.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax() is MethodDeclarationSyntax syntax)
+        // if a syntax is referenced the code written by the user copy all modifiers,
+        // otherwise only set private and optionally static
+        if (MethodDeclarationSyntax != null)
         {
-            return syntax.Modifiers.Select(x => TrailingSpacedToken(x.Kind()));
+            return MethodDeclarationSyntax.Modifiers.Select(x => TrailingSpacedToken(x.Kind()));
         }
 
         return isStatic ? _privateStaticSyntaxToken : _privateSyntaxToken;

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserDefinedExistingTargetMethodMapping.cs

@@ -22,7 +22,7 @@ bool enableReferenceHandling
 {
     private IExistingTargetMapping? _delegateMapping;
 
-    public IMethodSymbol Method { get; } = method;
+    public new IMethodSymbol Method { get; } = method;
 
     public bool? Default => false;
 

src/Riok.Mapperly/Descriptors/Mappings/UserMappings/UserDefinedNewInstanceGenericTypeMapping.cs

@@ -16,11 +16,10 @@ namespace Riok.Mapperly.Descriptors.Mappings.UserMappings;
 /// </summary>
 public class UserDefinedNewInstanceGenericTypeMapping(
     IMethodSymbol method,
-    GenericMappingTypeParameters typeParameters,
     MappingMethodParameters parameters,
     ITypeSymbol targetType,
     bool enableReferenceHandling,
-    NullFallbackValue nullArm,
+    NullFallbackValue? nullArm,
     ITypeSymbol objectType
 )
     : UserDefinedNewInstanceRuntimeTargetTypeMapping(
@@ -33,16 +32,16 @@ ITypeSymbol objectType
         objectType
     )
 {
-    public GenericMappingTypeParameters TypeParameters { get; } = typeParameters;
-
-    public override MethodDeclarationSyntax BuildMethod(SourceEmitterContext ctx) =>
-        base.BuildMethod(ctx).WithTypeParameterList(TypeParameterList(TypeParameters.SourceType, TypeParameters.TargetType));
+    public override MethodDeclarationSyntax BuildMethod(SourceEmitterContext ctx)
+    {
+        var methodSyntax = (MethodDeclarationSyntax)Method.DeclaringSyntaxReferences.First().GetSyntax();
+        return base.BuildMethod(ctx).WithTypeParameterList(methodSyntax.TypeParameterList);
+    }
 
     protected override ExpressionSyntax BuildTargetType()
     {
-        // typeof(TTarget) or typeof(<ReturnType>)
-        var targetTypeName = TypeParameters.TargetType ?? TargetType;
-        return TypeOfExpression(FullyQualifiedIdentifier(targetTypeName.NonNullable()));
+        // typeof(<ReturnType>)
+        return TypeOfExpression(FullyQualifiedIdentifier(Method.ReturnType.NonNullable()));
     }
 
     protected override ExpressionSyntax? BuildSwitchArmWhenClause(ExpressionSyntax targetType, RuntimeTargetTypeMapping mapping)