fix CI + add tests for #631

dadhi · dadhi · commit 5bc8c3e39d7e · 2024-02-14T23:03:42.000+01:00
diff --git a/src/DryIoc/Container.cs b/src/DryIoc/Container.cs
@@ -628,7 +628,7 @@ IEnumerable<object> IResolver.ResolveMany(Type serviceType, object serviceKey,
             ServiceRegistrationInfo[] variantGenericItems = null;
             if (requiredItemType.IsGenericType && Rules.VariantGenericTypesInResolvedCollection)
             {
-                variantGenericItems = GetServiceRegistrations(requiredItemType, 
+                variantGenericItems = GetServiceRegistrations(requiredItemType,
                     static (ref Type reqItType, ref ServiceRegistrationInfo src, out ServiceRegistrationInfo res) =>
                     {
                         res = src;
@@ -1021,7 +1021,7 @@ public Factory GetServiceFactoryOrDefault(Request request)
                 serviceFactories = r.Services;
 
             var rules = Rules;
-            if (rules.FactorySelector != null && serviceKey == null)
+            if (rules.FactorySelector != null & serviceKey == null)
                 return GetRuleSelectedServiceFactoryOrDefault(rules, serviceFactories, request, details, serviceType);
 
             var entry = serviceFactories.GetValueOrDefault(serviceType);
@@ -1043,7 +1043,7 @@ public Factory GetServiceFactoryOrDefault(Request request)
                     {
                         if (e.Value is Factory f)
                         {
-                            if ((serviceKey == null || serviceKey == DefaultKey.Value) &&
+                            if ((serviceKey == null | serviceKey == DefaultKey.Value) &&
                                 serviceType.IsAssignableVariantGenericTypeFrom(e.Key) &&
                                 request.MatchFactoryConditionAndMetadata(details, f))
                             {
@@ -1054,7 +1054,7 @@ public Factory GetServiceFactoryOrDefault(Request request)
                         else
                         {
                             foreach (var kf in ((FactoriesEntry)e.Value).Factories)
-                                if (kf.Key.Equals(serviceKey) && // todo: @wip take AnyKey into account?
+                                if (serviceKey.MatchToNotNullRegisteredKey(kf.Key) &&
                                     serviceType.IsAssignableVariantGenericTypeFrom(e.Key) &&
                                     request.MatchFactoryConditionAndMetadata(details, kf.Value))
                                 {
@@ -1114,8 +1114,8 @@ public Factory GetServiceFactoryOrDefault(Request request)
                 }
             }
             else // serviceKey == null
-            { 
-                factories = factories.Match(details, request, 
+            {
+                factories = factories.Match(details, request,
                     static (d, r, f) => (f.Key is DefaultKey | f.Key is DefaultDynamicKey) &&
                         r.MatchFactoryConditionAndMetadata(d, f.Value));
             }
@@ -1313,7 +1313,9 @@ private static KV<object, Factory> FindFactoryWithTheMinReuseLifespanOrDefault(K
                 var reuse = factory.Value.Reuse;
                 var lifespan = reuse == null | reuse == Reuse.Transient ? int.MaxValue : reuse.Lifespan;
                 if (lifespan == minLifespan)
+                {
                     multipleFactories = true;
+                }
                 else if (lifespan < minLifespan)
                 {
                     minLifespan = lifespan;
@@ -1322,7 +1324,7 @@ private static KV<object, Factory> FindFactoryWithTheMinReuseLifespanOrDefault(K
                 }
             }
 
-            return !multipleFactories && minLifespanFactory != null ? minLifespanFactory : null;
+            return !multipleFactories & minLifespanFactory != null ? minLifespanFactory : null;
         }
 
         ///  <inheritdoc />
@@ -5416,7 +5418,8 @@ private static Expression GetArrayExpression(Request request, Type collectionTyp
             if (requiredItemType.IsGenericType && rules.VariantGenericTypesInResolvedCollection)
             {
                 var variantGenericItems = container.GetServiceRegistrations(requiredItemType,
-                    static (ref Type reqItType, ref ServiceRegistrationInfo src, out ServiceRegistrationInfo res) => {
+                    static (ref Type reqItType, ref ServiceRegistrationInfo src, out ServiceRegistrationInfo res) =>
+                    {
                         res = src;
                         if (!reqItType.IsAssignableVariantGenericTypeFrom(src.ServiceType))
                             return false;
@@ -8173,13 +8176,13 @@ public static class Arg
     /// <summary>Contains <see cref="IRegistrator"/> extension methods to simplify general use cases.</summary>
     public static class Registrator
     {
-        // todo: @wip We are not supporting the AnyKey outside of the MS.DI, so that's confusing
         // todo: @feature We may need the paired DefaultKey to request/filter collections by default key, because AnyKey does not include DefaultKey
         /// <summary>When registered with it, the the service can be resolved any service key provided</summary>
         public static readonly object AnyKey = new AnyServiceKey();
         /// <summary>Wrap the resolution key</summary>
         public static object AnyKeyOfResolutionKey(object key) => new AnyServiceKey(key);
 
+        // todo: @wip add IConvertibleToExpression impl
         /// <summary>Represents the **registered** key that you may resolve with any resolution service key</summary>
         public class AnyServiceKey
         {
@@ -10190,6 +10193,7 @@ public static bool MatchFactoryConditionAndMetadata(this Request request, Servic
         public static bool MatchFactoryReuse(this Request r, Factory f) => f.Reuse?.CanApply(r) ?? true;
 
         /// <summary>Matching things</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool MatchGeneratedFactory(this Request r, Factory f) =>
             f.GeneratedFactories == null || f.GetGeneratedFactoryOrDefault(r, ifErrorReturnDefault: true) != null;
 
@@ -13333,7 +13337,7 @@ private static FactoryMethod GetClosedFactoryMethodOrDefault(
                 if (factoryMethodBase != null)
                 {
                     var targetMethods = closedFactoryImplType.GetMethods()
-                        .Match(factoryMember, factoryMethodBase.GetParameters(), 
+                        .Match(factoryMember, factoryMethodBase.GetParameters(),
                             static (fm, fp, m) => m.Name == fm.Name && m.GetParameters().Length == fp.Length);
 
                     if (targetMethods.Length == 1)
@@ -15904,7 +15908,7 @@ public static bool HasConversionOperatorTo(this Type sourceType, Type targetType
 
         /// <summary>Finds the conversion operator or returns null</summary>
         [MethodImpl((MethodImplOptions)256)]
-         public static MethodInfo GetConversionOperatorOrNull(this Type sourceType, Type targetType) =>
+        public static MethodInfo GetConversionOperatorOrNull(this Type sourceType, Type targetType) =>
             sourceType.FindConvertOperator(sourceType, targetType) ??
             targetType.FindConvertOperator(sourceType, targetType);
 
diff --git a/src/DryIoc/ImTools.cs b/src/DryIoc/ImTools.cs
@@ -37,7 +37,13 @@ namespace DryIoc.ImTools
     using System.Runtime.CompilerServices; // For [MethodImpl(AggressiveInlining)]
 
     /// <summary>General purpose Match operator</summary>
-    public delegate bool Match<S, T, R>(ref S state, ref T it, out R result);
+    public delegate bool MatchOp<S, T, R>(ref S state, ref T it, out R result);
+
+    /// <summary>General purpose Is operator</summary>
+    public delegate bool IsOp<S, T>(ref S state, ref T it);
+
+    /// <summary>General purpose Map operator</summary>
+    public delegate R MapOp<S, T, R>(ref S state, ref T it);
 
     /// <summary>Helpers for functional composition</summary>
     public static class Fun
@@ -662,6 +668,17 @@ private static R[] Copy<S, T, R>(this T[] source, S state, int sourcePos, int co
             return results;
         }
 
+        private static R[] Copy<S, T, R>(this T[] source, ref S state, int sourcePos, int count, MapOp<S, T, R> map)
+        {
+            var results = new R[count];
+            if (count == 1)
+                results[0] = map(ref state, ref source[sourcePos]);
+            else
+                for (int i = 0, j = sourcePos; i < count; ++i, ++j)
+                    results[i] = map(ref state, ref source[j]);
+            return results;
+        }
+
         private static R[] Copy<A, B, T, R>(this T[] source, A a, B b, int sourcePos, int count, Func<A, B, T, R> map)
         {
             var results = new R[count];
@@ -709,6 +726,18 @@ private static R[] AppendTo<S, T, R>(this T[] source, S state, R[] results, int
             return results;
         }
 
+        private static R[] AppendTo<S, T, R>(this T[] source, ref S state, R[] results, int sourcePos, int count, MapOp<S, T, R> map)
+        {
+            var oldResultsCount = results.Length;
+            Array.Resize(ref results, oldResultsCount + count);
+            if (count == 1)
+                results[oldResultsCount] = map(ref state, ref source[sourcePos]);
+            else
+                for (int i = oldResultsCount, j = sourcePos; i < results.Length; ++i, ++j)
+                    results[i] = map(ref state, ref source[j]);
+            return results;
+        }
+
         private static R[] AppendTo<A, B, T, R>(this T[] source, A a, B b, R[] results, int sourcePos, int count, Func<A, B, T, R> map)
         {
             var oldResultsCount = results.Length;
@@ -993,6 +1022,71 @@ public static R[] Match<S, T, R>(this T[] source, S state, Func<S, T, bool> cond
             return matches ?? (matchStart == 0 ? source.Copy(state, 0, source.Length, map) : Empty<R>());
         }
 
+        /// <summary>Match with the additional state to use in <paramref name="condition"/> and <paramref name="map"/> 
+        /// to minimize the allocations in <paramref name="condition"/> lambda closure </summary>
+        public static R[] Match<S, T, R>(this T[] source, ref S state, IsOp<S, T> condition, MapOp<S, T, R> map)
+        {
+            if (source == null)
+                return null;
+            if (source.Length == 0)
+                return Empty<R>();
+
+            if (source.Length == 1)
+            {
+                var item = source[0];
+                return condition(ref state, ref item) ? new[] { map(ref state, ref item) } : Empty<R>();
+            }
+
+            if (source.Length == 2)
+            {
+                var c0 = condition(ref state, ref source[0]);
+                var c1 = condition(ref state, ref source[1]);
+                return c0 & c1 ? new[] { map(ref state, ref source[0]), map(ref state, ref source[1]) }
+                    : c0 ? new[] { map(ref state, ref source[0]) }
+                    : c1 ? new[] { map(ref state, ref source[1]) }
+                    : Empty<R>();
+            }
+
+            if (source.Length == 3)
+            {
+                var c0 = condition(ref state, ref source[0]);
+                var c1 = condition(ref state, ref source[1]);
+                var c2 = condition(ref state, ref source[2]);
+                return c0 & c1 & c2 ? new[] { map(ref state, ref source[0]), map(ref state, ref source[1]), map(ref state, ref source[2]) }
+                    : c0 ? (c1 ? new[] { map(ref state, ref source[0]), map(ref state, ref source[1]) } 
+                        : c2 ? new[] { map(ref state, ref source[0]), map(ref state, ref source[2]) } 
+                        : new[] { map(ref state, ref source[0]) })
+                    : c1 ? (c2 ? new[] { map(ref state, ref source[1]), map(ref state, ref source[2]) } 
+                        : new[] { map(ref state, ref source[1]) })
+                    : c2 ? new[] { map(ref state, ref source[2]) }
+                    : Empty<R>();
+            }
+
+            var matchStart = 0;
+            R[] matches = null;
+            var matchFound = false;
+
+            var i = 0;
+            for (; i < source.Length; ++i)
+                if (!(matchFound = condition(ref state, ref source[i])))
+                {
+                    // for accumulated matched items
+                    if (i != 0 && i > matchStart)
+                        matches = matches == null 
+                            ? source.Copy(ref state, matchStart, i - matchStart, map)
+                            : source.AppendTo(ref state, matches, matchStart, i - matchStart, map);
+                    matchStart = i + 1; // guess the next match start will be after the non-matched item
+                }
+
+            // when last match was found but not all items are matched (hence matchStart != 0)
+            if (matchFound && matchStart != 0)
+                return matches == null
+                    ? source.Copy(ref state, matchStart, i - matchStart, map) 
+                    : source.AppendTo(ref state, matches, matchStart, i - matchStart, map);
+
+            return matches ?? (matchStart == 0 ? source.Copy(ref state, 0, source.Length, map) : Empty<R>());
+        }
+
         /// <summary>Match with the additional state to use in <paramref name="condition"/> and <paramref name="map"/> 
         /// to minimize the allocations in <paramref name="condition"/> lambda closure </summary>
         public static R[] Match<A, B, T, R>(this T[] source, A a, B b, Func<A, B, T, bool> condition, Func<A, B, T, R> map)
@@ -1091,6 +1185,28 @@ public static R[] Map<T, S, R>(this T[] source, S state, Func<S, T, R> map)
             return results;
         }
 
+        /// Map with additional state to use in <paramref name="map"/> to minimize allocations in <paramref name="map"/> lambda closure 
+        public static R[] Map<T, S, R>(this T[] source, ref S state, MapOp<S, T, R> map)
+        {
+            if (source == null)
+                return null;
+
+            var sourceCount = source.Length;
+            if (sourceCount == 0)
+                return Empty<R>();
+
+            if (sourceCount == 1)
+                return new[] { map(ref state, ref source[0]) };
+
+            if (sourceCount == 2)
+                return new[] { map(ref state, ref source[0]), map(ref state, ref source[1]) };
+
+            var results = new R[sourceCount];
+            for (var i = 0; i < source.Length; i++)
+                results[i] = map(ref state, ref source[i]);
+            return results;
+        }
+
         /// Map with additional two states to use in <paramref name="map"/> to minimize allocations in <paramref name="map"/> lambda closure 
         public static R[] Map<T, A, B, R>(this T[] source, A a, B b, Func<A, B, T, R> map)
         {
diff --git a/test/DryIoc.IssuesTests/GHIssue631_Conditional_registrations.cs b/test/DryIoc.IssuesTests/GHIssue631_Conditional_registrations.cs
@@ -0,0 +1,90 @@
+using NUnit.Framework;
+
+namespace DryIoc.IssuesTests;
+
+[TestFixture]
+public sealed class GHIssue631_Conditional_registrations : ITest
+{
+    public int Run()
+    {
+        // TestWithDefaultScopeToSingleton(); // todo: @fixme @wip the test
+        TestWithIdenticalScopes();
+        return 2;
+    }
+
+    [Test]
+    public void TestWithDefaultScopeToSingleton()
+    {
+        var container = new Container();
+
+        container.Register<IService, MyServiceA>(
+            reuse: Reuse.Transient,
+            setup: Setup.With(condition: request => request.DirectParent.ServiceType == typeof(ServiceConsumerA))
+        );
+
+        // the intention is having a default resolution if previous conditions aren't satisfied !!
+        container.Register<IService, MyServiceB>(
+            reuse: Reuse.Singleton
+        );
+
+        container.Register<ServiceConsumerA>();
+        container.Register<ServiceConsumerB>();
+
+        var consumerA = container.Resolve<ServiceConsumerA>();
+        var consumerB = container.Resolve<ServiceConsumerB>();
+
+        Assert.NotNull(consumerA);
+        Assert.NotNull(consumerB);
+
+        // here is the mismatch from consumerA.Service type !!.
+        Assert.IsInstanceOf<MyServiceA>(consumerA.Service);
+        Assert.IsInstanceOf<MyServiceB>(consumerB.Service);
+    }
+
+    [Test]
+    public void TestWithIdenticalScopes()
+    {
+        var container = new Container();
+
+        container.Register<IService, MyServiceA>(
+            reuse: Reuse.Transient,
+            setup: Setup.With(condition: request => request.DirectParent.ServiceType == typeof(ServiceConsumerA))
+        );
+
+        // the intention is having a default resolution if previous conditions aren't satisfied !!
+        container.Register<IService, MyServiceB>(
+            reuse: Reuse.Transient
+        );
+
+        container.Register<ServiceConsumerA>();
+        container.Register<ServiceConsumerB>();
+
+        var consumerA = container.Resolve<ServiceConsumerA>();
+        var consumerB = container.Resolve<ServiceConsumerB>();
+
+        Assert.NotNull(consumerA);
+        Assert.NotNull(consumerB);
+
+        // those asserts work, so types match !
+        Assert.IsInstanceOf<MyServiceA>(consumerA.Service);
+        Assert.IsInstanceOf<MyServiceB>(consumerB.Service);
+    }
+
+    public class ServiceConsumerA
+    {
+        public IService Service { get; private set; }
+        public ServiceConsumerA(IService service) => Service = service;
+    }
+
+    public class ServiceConsumerB
+    {
+        public IService Service { get; private set; }
+        public ServiceConsumerB(IService service) => Service = service;
+    }
+
+    public class MyServiceA : IService { }
+
+    public class MyServiceB : IService { }
+
+    public interface IService { }
+}
diff --git a/test/DryIoc.TestRunner/Program.cs b/test/DryIoc.TestRunner/Program.cs
@@ -9,10 +9,11 @@ public class Program
 {
     public static void Main()
     {
-        new GHIssue228_Updated_DryIoc_from_4_to_4_1_in_Unity_Engine_project_keyed_register_resolve_wont_work_anymore().Run();
+        new GHIssue631_Conditional_registrations().Run();
 
         RunAllTests();
 
+        // new GHIssue228_Updated_DryIoc_from_4_to_4_1_in_Unity_Engine_project_keyed_register_resolve_wont_work_anymore().Run();
         // new Issue397_ActionExportsTypeConversion().Run();
         // new GHIssue580_Scope_is_lost_in_IResolver_inside_scope_because_of_singleton().Run();
         // new GHIssue574_Cannot_register_multiple_impls_in_child_container_with_default_service_key().Run();

Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,11 @@ public class Program`
`9`	`9`	`{`
`10`	`10`	`public static void Main()`
`11`	`11`	`{`
`12`		`- new GHIssue228_Updated_DryIoc_from_4_to_4_1_in_Unity_Engine_project_keyed_register_resolve_wont_work_anymore().Run();`
	`12`	`+ new GHIssue631_Conditional_registrations().Run();`
`13`	`13`
`14`	`14`	`RunAllTests();`
`15`	`15`
	`16`	`+ // new GHIssue228_Updated_DryIoc_from_4_to_4_1_in_Unity_Engine_project_keyed_register_resolve_wont_work_anymore().Run();`
`16`	`17`	`// new Issue397_ActionExportsTypeConversion().Run();`
`17`	`18`	`// new GHIssue580_Scope_is_lost_in_IResolver_inside_scope_because_of_singleton().Run();`
`18`	`19`	`// new GHIssue574_Cannot_register_multiple_impls_in_child_container_with_default_service_key().Run();`