Error while mapping expression - InvalidOperationException: No coercion operator is defined between types

[Rujith]

AddExpressionMapping() not working for Expression with open generic mapping.

Source/destination types

    public class ReportS
    {
        public IList<MenuS<OptionS, Func<OptionS>>> Menu { get; set; }
    }

    public class ReportT
    {
        public IList<MenuT<OptionT, Func<OptionT>>> Menu { get; set; }
    }

    public class MenuT<T, TV>
    {
        public Expression<TV> LambdaExpression { get; set; }
        public T Option { get; set; }
    }

    public class MenuS<T, TV>
    {
        public Expression<TV> LambdaExpression { get; set; }
        public T Option { get; set; }
    }

    public class OptionS
    {
    }

    public class OptionT
    {
    }

Mapping configuration

 Mapper.Initialize(
                cfg =>
                    {
                        cfg.AddExpressionMapping();
                        cfg.CreateMap<OptionS, OptionT>();
                        cfg.CreateMap(typeof(MenuS<,>), typeof(MenuT<,>));
                        cfg.CreateMap<ReportS, ReportT>();
                    });

Version: x.y.z

Automapper 7.0.1
AutoMapper.Extensions.ExpressionMapping 1.0.3

Expected behavior

Expression should have mapped to target type

Actual behavior

InvalidOperationException: No coercion operator is defined between types 'OptionS' and 'OptionT'.

Steps to reproduce

  var source = new ReportS
                             {
                                 Menu = new List<MenuS<OptionS, Func<OptionS>>>
                                            {
                                                new MenuS<OptionS, Func<OptionS>>
                                                    {
                                                        Option = new OptionS(), LambdaExpression = () => new OptionS()
                                                    }
                                            }
                             };
            var target = Mapper.Map<ReportT>(source);

[BlaiseD]

Your expression is doing one thing which is not supported: Mapping constructors in expressions i.e. mapping new T1() to new T2().

And another which is not common - I don't think it is supported either which is: Mapping expressions with no parameters.

The following actually works if OptionS and OptionT are structs:

Expression<Func<OptionS>> exp = () => default(OptionS);
Expression<Func<OptionT>> expmapped = Mapper.Instance.MapExpression<Expression<Func<OptionS>>, Expression<Func<OptionT>>>(exp);

    public struct OptionS
    {
    }

    public struct OptionT
    {
    }

PRs are welcome.

[Rujith]

Thanks for fixing it

[BlaiseD]

np - partial fix. No solution yet for converting constructors. FYI the package can be accessed here before it is released to Nuget.