remove QueryMapperVisitor

Author: lbargaoanu

src/AutoMapper/ApiCompatBaseline.txt

@@ -13,4 +13,6 @@ CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMappe
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.UseExistingValueAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 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.
-Total Issues: 14
+MembersMustExist : Member 'public System.Linq.IQueryable<TDestination> AutoMapper.QueryableExtensions.Extensions.Map<TSource, TDestination>(System.Linq.IQueryable<TSource>, System.Linq.IQueryable<TDestination>, AutoMapper.IConfigurationProvider)' does not exist in the implementation but it does exist in the contract.
+TypesMustExist : Type 'AutoMapper.QueryableExtensions.Impl.MemberAccessQueryMapperVisitor' does not exist in the implementation but it does exist in the contract.
+Total Issues: 16

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -444,7 +444,7 @@ TypeMap GetIncludedTypeMap(TypePair pair)
                 // we want the exact map the user included, but we could instantiate an open generic
                 if (typeMap?.Types != pair)
                 {
-                    throw QueryMapperHelper.MissingMapException(pair);
+                    throw TypeMap.MissingMapException(pair);
                 }
                 return typeMap;
             }

src/AutoMapper/QueryableExtensions/Extensions.cs

@@ -16,17 +16,6 @@ namespace AutoMapper.QueryableExtensions
     public static class Extensions
     {
         /// <summary>
-        /// Maps a queryable expression of a source type to a queryable expression of a destination type
-        /// </summary>
-        /// <typeparam name="TSource">Source type</typeparam>
-        /// <typeparam name="TDestination">Destination type</typeparam>
-        /// <param name="sourceQuery">Source queryable</param>
-        /// <param name="destQuery">Destination queryable</param>
-        /// <param name="config"></param>
-        /// <returns>Mapped destination queryable</returns>
-        public static IQueryable<TDestination> Map<TSource, TDestination>(this IQueryable<TSource> sourceQuery, IQueryable<TDestination> destQuery, IConfigurationProvider config) => 
-            QueryMapperVisitor.Map(sourceQuery, destQuery, config.Internal());
-        /// <summary>
         /// Extension method to project from a queryable using the provided mapping engine
         /// </summary>
         /// <remarks>Projections are only calculated once and cached</remarks>

src/AutoMapper/QueryableExtensions/ProjectionBuilder.cs

@@ -74,7 +74,7 @@ public Expression CreateInnerProjection(in ProjectionRequest request, Expression
             CreateProjectionCore(request, instanceParameter, letPropertyMaps, out var _);
         private Expression CreateProjectionCore(in ProjectionRequest request, Expression instanceParameter, LetPropertyMaps letPropertyMaps, out TypeMap typeMap)
         {
-            typeMap = _configurationProvider.ResolveTypeMap(request.SourceType, request.DestinationType) ?? throw QueryMapperHelper.MissingMapException(request.SourceType, request.DestinationType);
+            typeMap = _configurationProvider.ResolveTypeMap(request.SourceType, request.DestinationType) ?? throw TypeMap.MissingMapException(request.SourceType, request.DestinationType);
             return CreateProjectionCore(request, instanceParameter, typeMap, letPropertyMaps);
         }
         private Expression CreateProjectionCore(ProjectionRequest request, Expression instanceParameter, TypeMap typeMap, LetPropertyMaps letPropertyMaps)

src/AutoMapper/QueryableExtensions/QueryMapperVisitor.cs

@@ -53,9 +53,12 @@ public void CheckProjection()
         {
             if (Projection)
             {
-                throw new AutoMapperConfigurationException("CreateProjection works with ProjectTo, not with Map.", QueryMapperHelper.MissingMapException(Types));
+                throw new AutoMapperConfigurationException("CreateProjection works with ProjectTo, not with Map.", MissingMapException(Types));
             }
         }
+        public static Exception MissingMapException(TypePair types) => MissingMapException(types.SourceType, types.DestinationType);
+        public static Exception MissingMapException(Type sourceType, Type destinationType)
+            => new InvalidOperationException($"Missing map from {sourceType} to {destinationType}. Create using CreateMap<{sourceType.Name}, {destinationType.Name}>.");
         public bool Projection { get; set; }
         public LambdaExpression MapExpression { get; private set; }
         internal bool CanConstructorMap() => Profile.ConstructorMappingEnabled && !DestinationType.IsAbstract &&