remove ITypeMapConfiguration

src/AutoMapper/ApiCompatBaseline.txt

@@ -11,6 +11,12 @@ MembersMustExist : Member 'public System.String AutoMapper.INamingConvention.Rep
 InterfacesShouldHaveSameMembers : Interface member 'public System.String[] AutoMapper.INamingConvention.Split(System.String)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.TypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' does not exist in the implementation but it does exist in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.TypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.ITypeMapConfiguration> AutoMapper.IProfileConfiguration.TypeMapConfigs.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.LowerUnderscoreNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.LowerUnderscoreNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.PascalCaseNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
@@ -19,7 +25,10 @@ MembersMustExist : Member 'public AutoMapper.IMappingOperationOptions AutoMapper
 TypesMustExist : Type 'AutoMapper.ValueResolverConfiguration' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Default interface member 'public System.Boolean AutoMapper.Configuration.IPropertyMapConfiguration.Ignored' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Default interface member 'public System.Boolean AutoMapper.Configuration.IPropertyMapConfiguration.Ignored.get()' is present in the implementation but not in the contract.
-MembersMustExist : Member 'public void AutoMapper.Configuration.MappingExpressionBase.Configure(AutoMapper.TypeMap)' does not exist in the implementation but it does exist in the contract.
+CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpression' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
+CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpression<TSource, TDestination>' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
+TypesMustExist : Type 'AutoMapper.Configuration.MappingExpressionBase' does not exist in the implementation but it does exist in the contract.
+CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpressionBase<TSource, TDestination, TMappingExpression>' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
 MembersMustExist : Member 'public void AutoMapper.Configuration.MappingExpressionBase<TSource, TDestination, TMappingExpression>.AsProxy()' 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.
@@ -40,4 +49,4 @@ MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Intern
 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.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Reflection.MemberInfo> AutoMapper.QueryableExtensions.MemberVisitor.MemberPath.get()' 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: 41
+Total Issues: 50

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -369,7 +369,7 @@ TypeMap FindClosedGenericMap(TypePair typePair)
                         FindTypeMapFor(genericTypePair.SourceType, typePair.DestinationType) ??
                         FindTypeMapFor(typePair.SourceType, genericTypePair.DestinationType) ??
                         FindTypeMapFor(genericTypePair);
-                    ITypeMapConfiguration genericMapConfig;
+                    TypeMapConfiguration genericMapConfig;
                     ProfileMap profile;
                     TypeMap cachedMap;
                     TypePair closedTypes;
@@ -461,7 +461,7 @@ void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
         }
         void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);
         void IGlobalConfiguration.Seal(TypeMap typeMap) => typeMap.Seal(this, _typeMapsPath);
-        void IGlobalConfiguration.RegisterAsMap(ITypeMapConfiguration typeMapConfiguration) =>
+        void IGlobalConfiguration.RegisterAsMap(TypeMapConfiguration typeMapConfiguration) =>
             _resolvedMaps[typeMapConfiguration.Types] = GetIncludedTypeMap(new(typeMapConfiguration.SourceType, typeMapConfiguration.DestinationTypeOverride));
     }
 }

src/AutoMapper/Configuration/MappingExpression.cs

@@ -3,18 +3,13 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using AutoMapper.Internal;
-
 namespace AutoMapper.Configuration
 {
     using Execution;
     public class MappingExpression : MappingExpressionBase<object, object, IMappingExpression>, IMappingExpression
     {
-        public MappingExpression(TypePair types, MemberList memberList) : base(memberList, types)
-        {
-        }
-
+        public MappingExpression(TypePair types, MemberList memberList) : base(memberList, types){}
         public string[] IncludedMembersNames { get; internal set; } = Array.Empty<string>();
-
         public IMappingExpression ReverseMap()
         {
             var reversedTypes = new TypePair(DestinationType, SourceType);
@@ -30,7 +25,6 @@ public IMappingExpression ReverseMap()
             }
             return reverseMap;
         }
-
         public IMappingExpression IncludeMembers(params string[] memberNames)
         {
             IncludedMembersNames = memberNames;
@@ -41,7 +35,6 @@ public IMappingExpression IncludeMembers(params string[] memberNames)
             TypeMapActions.Add(tm => tm.IncludedMembersNames = memberNames);
             return this;
         }
-
         public void ForAllMembers(Action<IMemberConfigurationExpression> memberOptions)
         {
             TypeMapActions.Add(typeMap =>
@@ -52,32 +45,23 @@ public void ForAllMembers(Action<IMemberConfigurationExpression> memberOptions)
                 }
             });
         }
-
         public IMappingExpression ForMember(string name, Action<IMemberConfigurationExpression> memberOptions)
         {
             var member = DestinationType.GetFieldOrProperty(name);
             ForMember(member, memberOptions);
             return this;
         }
-
         protected override void IgnoreDestinationMember(MemberInfo property, bool ignorePaths = true) => ForMember(property, o=>o.Ignore());
-
         internal MemberConfigurationExpression ForMember(MemberInfo destinationProperty, Action<IMemberConfigurationExpression> memberOptions)
         {
             var expression = new MemberConfigurationExpression(destinationProperty, SourceType);
-
             MemberConfigurations.Add(expression);
-
             memberOptions(expression);
-
             return expression;
         }
-
         public class MemberConfigurationExpression : MemberConfigurationExpression<object, object, object>, IMemberConfigurationExpression
         {
-            public MemberConfigurationExpression(MemberInfo destinationMember, Type sourceType) : base(destinationMember, sourceType)
-            {
-            }
+            public MemberConfigurationExpression(MemberInfo destinationMember, Type sourceType) : base(destinationMember, sourceType){}
             public void MapFrom(Type valueResolverType) => MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IValueResolver<,,>))));
             public void MapFrom(Type valueResolverType, string sourceMemberName) =>
                  MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IMemberValueResolver<,,,>)))
@@ -103,15 +87,10 @@ private void ConvertUsingCore(Type valueConverterType, string sourceMemberName =
                 });
         }
     }
-
-    public class MappingExpression<TSource, TDestination> :
-        MappingExpressionBase<TSource, TDestination, IMappingExpression<TSource, TDestination>>,
+    public class MappingExpression<TSource, TDestination> : MappingExpressionBase<TSource, TDestination, IMappingExpression<TSource, TDestination>>,
         IMappingExpression<TSource, TDestination>, IProjectionExpression<TSource, TDestination>
     {
-        public MappingExpression(MemberList memberList, bool projection = false) : base(memberList)
-        {
-            Projection = projection;
-        }
+        public MappingExpression(MemberList memberList, bool projection = false) : base(memberList) => Projection = projection;
         public MappingExpression(MemberList memberList, Type sourceType, Type destinationType) : base(memberList, sourceType, destinationType) { }
         public IMappingExpression<TSource, TDestination> ForPath<TMember>(Expression<Func<TDestination, TMember>> destinationMember,
             Action<IPathConfigurationExpression<TSource, TDestination, TMember>> memberOptions)
@@ -131,15 +110,12 @@ public IMappingExpression<TSource, TDestination> ForPath<TMember>(Expression<Fun
             memberOptions(expression);
             return this;
         }
-
         public IMappingExpression<TSource, TDestination> ForMember<TMember>(Expression<Func<TDestination, TMember>> destinationMember, Action<IMemberConfigurationExpression<TSource, TDestination, TMember>> memberOptions)
         {
             var memberInfo = ReflectionHelper.FindProperty(destinationMember);
             return ForDestinationMember(memberInfo, memberOptions);
         }
-
         private void IncludeMembersCore(LambdaExpression[] memberExpressions) => TypeMapActions.Add(tm => tm.IncludedMembers = memberExpressions);
-
         public IMappingExpression<TSource, TDestination> IncludeMembers(params Expression<Func<TSource, object>>[] memberExpressions)
         {
             var memberExpressionsWithoutCastToObject = Array.ConvertAll(
@@ -149,17 +125,14 @@ public IMappingExpression<TSource, TDestination> IncludeMembers(params Expressio
                     var bodyIsCastToObject = e.Body.NodeType == ExpressionType.Convert && e.Body.Type == typeof(object);
                     return bodyIsCastToObject ? Expression.Lambda(((UnaryExpression)e.Body).Operand, e.Parameters) : e;
                 });
-
             IncludeMembersCore(memberExpressionsWithoutCastToObject);
             return this;
         }
-
         public IMappingExpression<TSource, TDestination> ForMember(string name, Action<IMemberConfigurationExpression<TSource, TDestination, object>> memberOptions)
         {
             var member = DestinationType.GetFieldOrProperty(name);
             return ForDestinationMember(member, memberOptions);
         }
-
         public void ForAllMembers(Action<IMemberConfigurationExpression<TSource, TDestination, object>> memberOptions)
         {
             TypeMapActions.Add(typeMap =>
@@ -170,68 +143,43 @@ public void ForAllMembers(Action<IMemberConfigurationExpression<TSource, TDestin
                 }
             });
         }
-
-        public IMappingExpression<TSource, TDestination> Include<TOtherSource, TOtherDestination>()
-            where TOtherSource : TSource
-            where TOtherDestination : TDestination
+        public IMappingExpression<TSource, TDestination> Include<TOtherSource, TOtherDestination>() where TOtherSource : TSource where TOtherDestination : TDestination
         {
             IncludeCore(typeof(TOtherSource), typeof(TOtherDestination));
-
             return this;
         }
-
-        public IMappingExpression<TSource, TDestination> IncludeBase<TSourceBase, TDestinationBase>() 
-            => IncludeBase(typeof(TSourceBase), typeof(TDestinationBase));
-
+        public IMappingExpression<TSource, TDestination> IncludeBase<TSourceBase, TDestinationBase>() => IncludeBase(typeof(TSourceBase), typeof(TDestinationBase));
         public IMappingExpression<TSource, TDestination> ForSourceMember(Expression<Func<TSource, object>> sourceMember, Action<ISourceMemberConfigurationExpression> memberOptions)
         {
             var memberInfo = ReflectionHelper.FindProperty(sourceMember);
-
             var srcConfig = new SourceMappingExpression(memberInfo);
-
             memberOptions(srcConfig);
-
             SourceMemberConfigurations.Add(srcConfig);
-
             return this;
         }
-
         public void As<T>() where T : TDestination => As(typeof(T));
-
         public IMappingExpression<TSource, TDestination> AddTransform<TValue>(Expression<Func<TValue, TValue>> transformer)
         {
             var config = new ValueTransformerConfiguration(typeof(TValue), transformer);
-
             ValueTransformers.Add(config);
-
             return this;
         }
-
         public IMappingExpression<TDestination, TSource> ReverseMap()
         {
-            var reverseMap = new MappingExpression<TDestination, TSource>(MemberList.None, DestinationType, SourceType)
-            {
-                IsReverseMap = true
-            };
+            var reverseMap = new MappingExpression<TDestination, TSource>(MemberList.None, DestinationType, SourceType){ IsReverseMap = true };
             ReverseMapCore(reverseMap);
             reverseMap.IncludeMembersCore(MapToSourceMembers().Select(m => m.GetDestinationExpression()).ToArray());
             return reverseMap;
         }
-
         private IMappingExpression<TSource, TDestination> ForDestinationMember<TMember>(MemberInfo destinationProperty, Action<MemberConfigurationExpression<TSource, TDestination, TMember>> memberOptions)
         {
             var expression = new MemberConfigurationExpression<TSource, TDestination, TMember>(destinationProperty, SourceType);
-
             MemberConfigurations.Add(expression);
-
             memberOptions(expression);
-
             return this;
         }
-
-        protected override void IgnoreDestinationMember(MemberInfo property, bool ignorePaths = true) 
-            => ForDestinationMember<object>(property, options => options.Ignore(ignorePaths));
-
+        protected override void IgnoreDestinationMember(MemberInfo property, bool ignorePaths = true) => 
+            ForDestinationMember<object>(property, options => options.Ignore(ignorePaths));
         IProjectionExpression<TSource, TDestination> IProjectionExpression<TSource, TDestination>.ForMember<TMember>(Expression<Func<TDestination, TMember>> destinationMember,
             Action<IProjectionMemberConfiguration<TSource, TDestination, TMember>> memberOptions) => 
             (IProjectionExpression<TSource, TDestination>)ForMember(destinationMember, memberOptions);