CompileMappings throws an exception

[botinko]

Source/destination types

  public class MyClassFrom
  {
      public List<long> LongList { get; set; }
  }

  public class MyClassTo : MyClassToBase
  {
  }

  public class MyClassToBase
  {
      public Option<IEnumerable<long>> LongList { get; set; }
  }

// From https://www.nuget.org/packages/Option
public struct Option<T> : IEquatable<Functional.Option.Option<T>>, IEnumerable<T>, IEnumerable 
{
}

Mapping configuration

  var configuration = new MapperConfiguration(
      c => {
          c.CreateMap<MyClassFrom, MyClassToBase>().ForMember(c => c.LongList, e => e.Ignore());
          c.CreateMap<MyClassFrom, MyClassTo>().IncludeBase<MyClassFrom, MyClassToBase>();
      });

Version: 12.0.0 and 12.0.2-preview.0.4

Expected behavior

configuration.CompileMappings(); wont throw.

Actual behavior

System.NotSupportedException : Unknown collection. Consider a custom type converter from System.Collections.Generic.List`1[System.Int64] to Functional.Option.Option`1[System.Collections.Generic.IEnumerable`1[System.Int64]].
   at AutoMapper.Internal.Mappers.CollectionMapper.<MapExpression>g__MapCollectionCore|2_1(Expression destExpression, <>c__DisplayClass2_0&)
   at AutoMapper.Internal.Mappers.CollectionMapper.MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
   at AutoMapper.MapperConfiguration.<AutoMapper.Internal.IGlobalConfiguration.BuildExecutionPlan>g__GenerateObjectMapperExpression|28_2(MapRequest& mapRequest, IObjectMapper mapper)
   at AutoMapper.MapperConfiguration.AutoMapper.Internal.IGlobalConfiguration.BuildExecutionPlan(MapRequest& mapRequest)
   at AutoMapper.MapperConfiguration.<.ctor>g__CompileExecutionPlan|20_2(MapRequest mapRequest)
   at AutoMapper.Internal.LockingConcurrentDictionary`2.<>c__DisplayClass2_1.<.ctor>b__1()
   at System.Lazy`1.ViaFactory(LazyThreadSafetyMode mode)
   at System.Lazy`1.ExecutionAndPublication(LazyHelper executionAndPublication, Boolean useDefaultConstructor)
   at System.Lazy`1.CreateValue()
   at AutoMapper.Internal.LockingConcurrentDictionary`2.GetOrAdd(TKey& key)
   at AutoMapper.MapperConfiguration.GetExecutionPlan(MapRequest& mapRequest)
   at AutoMapper.MapperConfiguration.CompileMappings()
   at ServiceTitan.Crm.Tests.Test() in C:\ServiceTitan\app\Apps\App.Api.Tests\Test.cs:line 81
   at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
   at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)

Steps to reproduce

Test to reproduce:

    public class MyClassFrom
    {
        public List<long> LongList { get; set; }
    }

    public class MyClassTo : MyClassToBase
    {
    }

    public class MyClassToBase
    {
        public Option<IEnumerable<long>> LongList { get; set; }
    }

    [Test]
    public void Test()
    {
        var configuration = new MapperConfiguration(
            c => {
                c.CreateMap<MyClassFrom, MyClassToBase>().ForMember(c => c.LongList, e => e.Ignore());
                c.CreateMap<MyClassFrom, MyClassTo>().IncludeBase<MyClassFrom, MyClassToBase>();
            });
        var mapper = configuration.CreateMapper();

        // works as expected
        mapper.Map<MyClassFrom, MyClassTo>(new MyClassFrom() {
            LongList = new List<long>(){1}
        });

        // throws
        configuration.CompileMappings();
    }

It turns out, that Ignore won't taken into account while using IncludeBase, so in CompileMappings AutoMapper tries to compile List<long> to Option<IEnumerable<long>>. But this conversion won't present in configuration.

Ignoring LongList explicitly helps.

Is it excected behavior or bug?

[lbargaoanu]

A PR is welcome.