ProjectTo runtime polymorphic mapping with Include/IncludeBase

AutoMapper.sln

@@ -26,7 +26,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoMapper.UnitTests", "src
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoMapper.IntegrationTests", "src\IntegrationTests\AutoMapper.IntegrationTests.csproj", "{24B47F4C-0035-4F29-AAD9-4C47E1AAD98E}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoMapper.DI.Tests", "src\AutoMapper.Extensions.Microsoft.DependencyInjection.Tests\AutoMapper.DI.Tests.csproj", "{BEBD620A-8BAA-463F-BE0F-8319AD3C1644}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoMapper.DI.Tests", "src\AutoMapper.DI.Tests\AutoMapper.DI.Tests.csproj", "{BEBD620A-8BAA-463F-BE0F-8319AD3C1644}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestApp", "src\TestApp\TestApp.csproj", "{35CED3AE-B825-4703-992D-A58B5BE646DC}"
 EndProject

README.md

@@ -10,7 +10,6 @@ AutoMapper is a simple little library built to solve a deceptively complex probl
 
 This is the main repository for AutoMapper, but there's more:
 
-* [Microsoft DI Extensions](https://github.com/AutoMapper/AutoMapper.Extensions.Microsoft.DependencyInjection)
 * [Collection Extensions](https://github.com/AutoMapper/AutoMapper.Collection)
 * [Expression Mapping](https://github.com/AutoMapper/AutoMapper.Extensions.ExpressionMapping)
 * [EF6 Extensions](https://github.com/AutoMapper/AutoMapper.EF6)

docs/13.0-Upgrade-Guide.md

@@ -12,4 +12,8 @@ Besides the build-time impact, there is also a behaviour change. Non-generic `Ma
 
 ## `AllowAdditiveTypeMapCreation` was removed
 
-Be sure to call `CreateMap` once for a source type, destination type pair. If you want to reuse configuration, use mapping inheritance.
+Be sure to call `CreateMap` once for a source type, destination type pair. If you want to reuse configuration, use mapping inheritance.
+
+## ProjectTo runtime polymorphic mapping with Include/IncludeBase
+
+We consider this an off the beaten path feature and we don't expose it through `CreateProjection`. You can use [an extension method](https://github.com/AutoMapper/AutoMapper/search?l=C%23&q=Advanced) or `CreateMap`.

docs/Queryable-Extensions.md

@@ -227,6 +227,7 @@ Not all mapping options can be supported, as the expression generated must be in
 * NullSubstitute
 * Value transformers
 * IncludeMembers
+* Runtime polymorphic mapping with Include/IncludeBase
 
 Not supported:
 * Condition
@@ -237,6 +238,5 @@ Not supported:
 * Custom resolvers
 * Custom type converters
 * ForPath
-* Value converters
-* Runtime polymorphic mapping with Include/IncludeBase
+* Value converters
 * **Any calculated property on your domain object**

src/AutoMapper/ApiCompatBaseline.txt

@@ -3,7 +3,11 @@ CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMappe
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.PropertyMapAction> AutoMapper.IProfileConfiguration.AllPropertyMapActions.get()' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<System.Action<AutoMapper.PropertyMap, AutoMapper.IMemberConfigurationExpression>> AutoMapper.IProfileConfiguration.AllPropertyMapActions.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Action<AutoMapper.PropertyMap, AutoMapper.IMemberConfigurationExpression>> AutoMapper.IProfileConfiguration.AllPropertyMapActions.get()' does not exist in the implementation but it does exist in the contract.
-InterfacesShouldHaveSameMembers : Interface member 'public void AutoMapper.Configuration.ICtorParamConfigurationExpression.ExplicitExpansion()' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public void AutoMapper.IProjectionMemberConfiguration<TSource, TDestination, TMember>.ExplicitExpansion()' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public void AutoMapper.IProjectionMemberConfiguration<TSource, TDestination, TMember>.ExplicitExpansion()' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public void AutoMapper.IProjectionMemberConfiguration<TSource, TDestination, TMember>.ExplicitExpansion(System.Boolean)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public void AutoMapper.Configuration.ICtorParamConfigurationExpression.ExplicitExpansion(System.Boolean)' is present in the implementation but not in the contract.
+MembersMustExist : Member 'public void AutoMapper.Configuration.MemberConfigurationExpression<TSource, TDestination, TMember>.ExplicitExpansion()' does not exist in the implementation but it does exist in the contract.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.IgnoreAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.MapAtRuntimeAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.MappingOrderAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
@@ -13,4 +17,4 @@ CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMappe
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueConverterAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueResolverAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 TypeCannotChangeClassification : Type 'AutoMapper.Execution.TypeMapPlanBuilder' is a 'ref struct' in the implementation but is a 'struct' in the contract.
-Total Issues: 14
+Total Issues: 18

src/AutoMapper/Configuration/ConfigurationValidator.cs

@@ -116,7 +116,7 @@ private void CheckPropertyMaps(IGlobalConfiguration config, HashSet<TypeMap> typ
             // when we don't know what the source type is, bail
             if (sourceType.IsGenericParameter || sourceType == typeof(object))
             {
-                return;
+                continue;
             }
             DryRunTypeMap(config, typeMapsChecked, new(sourceType, memberMap.DestinationType), null, memberMap);
         }

src/AutoMapper/Configuration/CtorParamConfigurationExpression.cs

@@ -1,6 +1,4 @@
-using System.Runtime.CompilerServices;
-namespace AutoMapper.Configuration;
-
+namespace AutoMapper.Configuration;
 public interface ICtorParamConfigurationExpression
 {
     /// <summary>
@@ -11,7 +9,8 @@ public interface ICtorParamConfigurationExpression
     /// <summary>
     /// Ignore this member for LINQ projections unless explicitly expanded during projection
     /// </summary>
-    void ExplicitExpansion();
+    /// <param name="value">Is explicitExpansion active</param>
+    void ExplicitExpansion(bool value = true);
 }
 public interface ICtorParamConfigurationExpression<TSource> : ICtorParamConfigurationExpression
 {
@@ -63,7 +62,7 @@ public void MapFrom(string sourceMembersPath)
         _ctorParamActions.Add(cpm => cpm.MapFrom(sourceMembersPath, sourceMembers));
     }
 
-    public void ExplicitExpansion() => _ctorParamActions.Add(cpm => cpm.ExplicitExpansion = true);
+    public void ExplicitExpansion(bool value) => _ctorParamActions.Add(cpm => cpm.ExplicitExpansion = value);
 
     public void Configure(TypeMap typeMap)
     {

src/AutoMapper/Configuration/IMemberConfigurationExpression.cs

@@ -290,7 +290,8 @@ public interface IProjectionMemberConfiguration<TSource, TDestination, TMember>
     /// <summary>
     /// Ignore this member for LINQ projections unless explicitly expanded during projection
     /// </summary>
-    void ExplicitExpansion();
+    /// <param name="value">Is explicitExpansion active</param>
+    void ExplicitExpansion(bool value = true);
     /// <summary>
     /// Apply a transformation function after any resolved destination member value with the given type
     /// </summary>

src/AutoMapper/Configuration/MemberConfigurationExpression.cs

@@ -80,7 +80,7 @@ private void PreConditionCore(Expression<Func<TSource, TDestination, ResolutionC
         PropertyMapActions.Add(pm => pm.PreCondition = expr);
     public void AddTransform(Expression<Func<TMember, TMember>> transformer) =>
         PropertyMapActions.Add(pm => pm.AddValueTransformation(new ValueTransformerConfiguration(pm.DestinationType, transformer)));
-    public void ExplicitExpansion() => PropertyMapActions.Add(pm => pm.ExplicitExpansion = true);
+    public void ExplicitExpansion(bool value) => PropertyMapActions.Add(pm => pm.ExplicitExpansion = value);
     public void Ignore() => Ignore(ignorePaths: true);
     public void Ignore(bool ignorePaths)
     {

src/AutoMapper/ConstructorMap.cs

@@ -17,11 +17,11 @@ public bool CanResolve
         get => _canResolve ??= ParametersCanResolve();
         set => _canResolve = value;
     }
-    private bool ParametersCanResolve()
+    bool ParametersCanResolve()
     {
         foreach (var param in _ctorParams)
         {
-            if (!param.CanResolveValue)
+            if (!param.IsMapped)
             {
                 return false;
             }
@@ -42,29 +42,26 @@ public ConstructorParameterMap this[string name]
             return null;
         }
     }
-    public void AddParameter(ParameterInfo parameter, IEnumerable<MemberInfo> sourceMembers, TypeMap typeMap) =>
-        _ctorParams.Add(new(typeMap, parameter, sourceMembers.ToArray()));
-    public bool ApplyIncludedMember(IncludedMember includedMember)
+    public void AddParameter(ParameterInfo parameter, IEnumerable<MemberInfo> sourceMembers, TypeMap typeMap) => _ctorParams.Add(new(typeMap, parameter, sourceMembers.ToArray()));
+    public bool ApplyMap(TypeMap typeMap, IncludedMember includedMember = null)
     {
-        var includedMap = includedMember.TypeMap.ConstructorMap;
-        if (CanResolve || includedMap?.Ctor != Ctor)
+        var constructorMap = typeMap.ConstructorMap;
+        if(constructorMap == null)
         {
             return false;
         }
-        bool canResolve = false;
-        var includedParams = includedMap._ctorParams;
-        for(int index = 0; index < includedParams.Count; index++)
+        bool applied = false;
+        foreach(var parameterMap in _ctorParams)
         {
-            var includedParam = includedParams[index];
-            if (!includedParam.CanResolveValue || _ctorParams[index].CanResolveValue)
+            var inheritedParameterMap = constructorMap[parameterMap.DestinationName];
+            if(inheritedParameterMap is not { IsMapped: true, DestinationType: var type } || type != parameterMap.DestinationType || !parameterMap.ApplyMap(inheritedParameterMap, includedMember))
             {
                 continue;
             }
-            canResolve = true;
+            applied = true;
             _canResolve = null;
-            _ctorParams[index] = new(includedParam, includedMember);
         }
-        return canResolve;
+        return applied;
     }
 }
 [EditorBrowsable(EditorBrowsableState.Never)]
@@ -82,16 +79,26 @@ public ConstructorParameterMap(TypeMap typeMap, ParameterInfo parameter, MemberI
             SourceMembers = Array.Empty<MemberInfo>();
         }
     }
-    public ConstructorParameterMap(ConstructorParameterMap parameterMap, IncludedMember includedMember) : 
-        this(includedMember.TypeMap, parameterMap.Parameter, parameterMap.SourceMembers) =>
-        IncludedMember = includedMember.Chain(parameterMap.IncludedMember);
     public ParameterInfo Parameter { get; }
     public override Type DestinationType => Parameter.ParameterType;
-    public override IncludedMember IncludedMember { get; }
+    public override IncludedMember IncludedMember { get; protected set; }
     public override MemberInfo[] SourceMembers { get; set; }
     public override string DestinationName => Parameter.Name;
     public Expression DefaultValue(IGlobalConfiguration configuration) => Parameter.IsOptional ? Parameter.GetDefaultValue(configuration) : configuration.Default(DestinationType);
-    public override string ToString() => $"{Constructor}, parameter {DestinationName}";
-    private MemberInfo Constructor => Parameter.Member;
+    public override string ToString() => $"{Parameter.Member}, parameter {DestinationName}";
+    public bool ApplyMap(ConstructorParameterMap inheritedParameterMap, IncludedMember includedMember)
+    {
+        if(includedMember != null && IsMapped)
+        {
+            return false;
+        }
+        ExplicitExpansion ??= inheritedParameterMap.ExplicitExpansion;
+        if(ApplyInheritedMap(inheritedParameterMap))
+        {
+            IncludedMember = includedMember?.Chain(inheritedParameterMap.IncludedMember);
+            return true;
+        }
+        return false;
+    }
     public override bool? ExplicitExpansion { get; set; }
 }

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -362,10 +362,10 @@ private static Expression Replace(this ParameterReplaceVisitor visitor, LambdaEx
         return newLambda;
     }
     public static Expression Replace(this Expression exp, Expression old, Expression replace) => new ReplaceVisitor().Replace(exp, old, replace);
-    public static Expression NullCheck(this Expression expression, IGlobalConfiguration configuration, MemberMap memberMap = null, Expression defaultValue = null)
+    public static Expression NullCheck(this Expression expression, IGlobalConfiguration configuration, MemberMap memberMap = null, Expression defaultValue = null, IncludedMember includedMember = null)
     {
         var chain = expression.GetChain();
-        var min = memberMap?.IncludedMember == null ? 2 : 1;
+        var min = (includedMember ?? memberMap?.IncludedMember) == null ? 2 : 1;
         if (chain.Count < min || chain.Peek().Target is not ParameterExpression parameter)
         {
             return expression;

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -109,7 +109,7 @@ private static void CheckForCycles(IGlobalConfiguration configuration, TypeMap t
             }
             if (typeMapsPath.Contains(memberTypeMap))
             {
-                if (memberTypeMap.SourceType.IsValueType)
+                if (memberTypeMap.SourceType.IsValueType || memberTypeMap.DestinationType.IsValueType)
                 {
                     if (memberTypeMap.MaxDepth == 0)
                     {

src/AutoMapper/Mapper.cs

@@ -15,7 +15,7 @@ public interface IMapperBase
     /// <summary>
     /// Execute a mapping from the source object to a new destination object.
     /// </summary>
-    /// <typeparam name="TSource">Source type to use, regardless of the runtime type</typeparam>
+    /// <typeparam name="TSource">Source type to use</typeparam>
     /// <typeparam name="TDestination">Destination type to create</typeparam>
     /// <param name="source">Source object to map from</param>
     /// <returns>Mapped destination object</returns>

src/AutoMapper/MemberMap.cs

@@ -1,5 +1,3 @@
-using System.Security.AccessControl;
-
 namespace AutoMapper;
 /// <summary>
 /// The base class for member maps (property, constructor and path maps).
@@ -22,12 +20,12 @@ public void SetResolver(IValueResolver resolver)
     }
     public virtual Type SourceType => _sourceType ??= GetSourceType();
     public virtual MemberInfo[] SourceMembers { get => Array.Empty<MemberInfo>(); set { } }
-    public virtual IncludedMember IncludedMember => null;
+    public virtual IncludedMember IncludedMember { get => default; protected set { } }
     public virtual string DestinationName => default;
     public virtual Type DestinationType { get => default; protected set { } }
     public virtual TypePair Types() => new(SourceType, DestinationType);
     public bool CanResolveValue => !Ignored && Resolver != null;
-    public bool IsMapped => Ignored || CanResolveValue;
+    public bool IsMapped => Ignored || Resolver != null;
     public virtual bool Ignored { get => default; set { } }
     public virtual bool? ExplicitExpansion { get => default; set { } }
     public virtual bool Inline { get; set; } = true;
@@ -65,6 +63,31 @@ public void MapByConvention(MemberInfo[] sourceMembers)
         SourceMembers = sourceMembers;
         Resolver = this;
     }
+    protected bool ApplyInheritedMap(MemberMap inheritedMap)
+    {
+        if(Ignored || IsResolveConfigured)
+        {
+            return false;
+        }
+        if(inheritedMap.Ignored)
+        {
+            Ignored = true;
+            return true;
+        }
+        if(inheritedMap.IsResolveConfigured)
+        {
+            _sourceType = inheritedMap._sourceType;
+            Resolver = inheritedMap.Resolver.CloseGenerics(TypeMap);
+            return true;
+        }
+        if(Resolver == null)
+        {
+            _sourceType = inheritedMap._sourceType;
+            MapByConvention(inheritedMap.SourceMembers);
+            return true;
+        }
+        return false;
+    }
     Expression IValueResolver.GetExpression(IGlobalConfiguration configuration, MemberMap memberMap, Expression source, Expression destination, Expression destinationMember) =>
         ChainSourceMembers(configuration, source, destinationMember);
     MemberInfo IValueResolver.GetSourceMember(MemberMap memberMap) => SourceMembers[0];

src/AutoMapper/PathMap.cs

@@ -22,6 +22,6 @@ public PathMap(LambdaExpression destinationExpression, MemberPath memberPath, Ty
     public override string DestinationName => MemberPath.ToString();
     public override bool CanBeSet => ReflectionHelper.CanBeSet(MemberPath.Last);
     public override bool Ignored { get; set; }
-    public override IncludedMember IncludedMember { get; }
+    public override IncludedMember IncludedMember { get; protected set; }
     public override LambdaExpression Condition { get; set; }
 }