public static IDataSource Create(
            IQualifiedMember sourceMember,
            int dataSourceIndex,
            IChildMemberMappingData childMappingData)
        {
            var childMapperData = childMappingData.MapperData;

            if (!childMapperData.MapperContext.UserConfigurations.HasMappingFactories)
            {
                return(new NullDataSource(Constants.EmptyExpression));
            }

            var childObjectMappingData = ObjectMappingDataFactory.ForChild(
                sourceMember,
                childMapperData.TargetMember,
                dataSourceIndex,
                childMappingData.Parent);

            var childCreationContext = new MappingCreationContext(childObjectMappingData);

            var mapping = ConfiguredMappingFactory
                          .GetMappingOrNull(childCreationContext, out _);

            if (mapping == null)
            {
                return(new NullDataSource(Constants.EmptyExpression));
            }

            var childObjectMapperData = childObjectMappingData.MapperData;
            var sourceMemberAccess    = sourceMember.GetRelativeQualifiedAccess(childMapperData);
            var targetMemberAccess    = childMapperData.GetTargetMemberAccess();

            var mappingValues = new MappingValues(
                sourceMemberAccess,
                targetMemberAccess,
                childMapperData.ElementIndex,
                childMapperData.ElementKey,
                dataSourceIndex);

            var directAccessMapping = MappingFactory.GetDirectAccessMapping(
                mapping,
                childObjectMapperData,
                mappingValues,
                MappingDataCreationFactory.ForChild(mappingValues, childObjectMapperData));

            var returnValue = childObjectMapperData
                              .GetFinalisedReturnValue(directAccessMapping, out var returnsDefault);

            if (returnsDefault)
            {
                returnValue = Expression.Block(directAccessMapping, returnValue);
            }

            return(new AdHocDataSource(sourceMember, returnValue, childMapperData));
        }
        private static IDataSource ApplyFilterIfAppropriate(
            IQualifiedMember sourceMember,
            IDataSource dataSource,
            IMemberMapperData mapperData)
        {
            if (DoNotApplyFilter(sourceMember, dataSource, mapperData))
            {
                return(dataSource);
            }

            var filters = mapperData.GetSourceValueFilters(sourceMember.Type);

            if (filters.None())
            {
                return(dataSource);
            }

            var contextMapperData = mapperData.IsEntryPoint || (sourceMember != mapperData.SourceMember)
                ? mapperData
                : mapperData.Parent;

            var rawSourceValue   = sourceMember.GetRelativeQualifiedAccess(contextMapperData);
            var filterConditions = filters.GetFilterConditionsOrNull(rawSourceValue, contextMapperData);

            if (filterConditions == null)
            {
                return(dataSource);
            }

            if (dataSource.IsConditional)
            {
                filterConditions = Expression.AndAlso(dataSource.Condition, filterConditions);
            }

            return(new AdHocDataSource(sourceMember, dataSource.Value, filterConditions));
        }