Adding support for constrained open generics

src/DependencyInjection/DI.Specification.Tests/src/DependencyInjectionSpecificationTests.cs

@@ -545,6 +545,29 @@ public void OpenGenericServicesCanBeResolved()
             Assert.Same(singletonService, genericService.Value);
         }
 
+        [Fact]
+        public void ConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ConstrainedFakeOpenGenericService<>));
+            var poco = new PocoClass();
+            collection.AddSingleton(poco);
+            collection.AddSingleton<IFakeSingletonService, FakeService>();
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<IFakeSingletonService>>().ToList();
+            var singletonService = provider.GetService<IFakeSingletonService>();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Same(poco, allServices[0].Value);
+            Assert.Same(poco, allServices[1].Value);
+            Assert.Equal(1, constrainedServices.Count);
+            Assert.Same(singletonService, constrainedServices[0].Value);
+        }
+
         [Fact]
         public void ClosedServicesPreferredOverOpenGenericServices()
         {

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ConstrainedFakeOpenGenericService.cs

@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ConstrainedFakeOpenGenericService<TVal> : IFakeOpenGenericService<TVal>
+        where TVal : PocoClass
+    {
+        public ConstrainedFakeOpenGenericService(TVal value)
+        {
+            Value = value;
+        }
+        public TVal Value { get; }
+    }
+}

src/DependencyInjection/DI/src/ServiceLookup/CallSiteFactory.cs

@@ -110,8 +110,7 @@ private ServiceCallSite TryCreateExact(Type serviceType, CallSiteChain callSiteC
 
         private ServiceCallSite TryCreateOpenGeneric(Type serviceType, CallSiteChain callSiteChain)
         {
-            if (serviceType.IsConstructedGenericType
-                && _descriptorLookup.TryGetValue(serviceType.GetGenericTypeDefinition(), out var descriptor))
+            if (serviceType.IsConstructedGenericType && _descriptorLookup.TryGetValue(serviceType.GetGenericTypeDefinition(), out var descriptor))
             {
                 return TryCreateOpenGeneric(descriptor.Last, serviceType, callSiteChain, DefaultSlot);
             }
@@ -211,7 +210,8 @@ private ServiceCallSite TryCreateExact(ServiceDescriptor descriptor, Type servic
         private ServiceCallSite TryCreateOpenGeneric(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain, int slot)
         {
             if (serviceType.IsConstructedGenericType &&
-                serviceType.GetGenericTypeDefinition() == descriptor.ServiceType)
+                serviceType.GetGenericTypeDefinition() == descriptor.ServiceType &&
+                IsCompatibleWithGenericParameterConstraints(descriptor.ImplementationType, serviceType.GenericTypeArguments))
             {
                 Debug.Assert(descriptor.ImplementationType != null, "descriptor.ImplementationType != null");
                 var lifetime = new ResultCache(descriptor.Lifetime, serviceType, slot);
@@ -358,6 +358,119 @@ private ServiceCallSite[] CreateArgumentCallSites(
             return parameterCallSites;
         }
 
+        private static bool IsCompatibleWithGenericParameterConstraints(Type genericTypeDefinition, Type[] parameters)
+        {
+            var genericArgumentDefinitions = genericTypeDefinition.GetTypeInfo().GenericTypeParameters;
+            for (var i = 0; i < genericArgumentDefinitions.Length; ++i)
+            {
+                var argumentDefinitionTypeInfo = genericArgumentDefinitions[i].GetTypeInfo();
+                var parameter = parameters[i];
+                var parameterTypeInfo = parameter.GetTypeInfo();
+                foreach (var constraint in argumentDefinitionTypeInfo.GetGenericParameterConstraints())
+                {
+                    var substituteGenericParameterConstraint = SubstituteGenericParameterConstraint(parameters, constraint);
+                    if (!ParameterCompatibleWithTypeConstraint(parameter, substituteGenericParameterConstraint))
+                    {
+                        return false;
+                    }
+                }
+
+                var specialConstraints = argumentDefinitionTypeInfo.GenericParameterAttributes;
+                if ((specialConstraints & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint)
+                {
+                    if (!parameterTypeInfo.IsValueType && parameterTypeInfo.DeclaredConstructors.Where(c => c.IsPublic).All(c => c.GetParameters().Length != 0))
+                    {
+                        return false;
+                    }
+                }
+                if ((specialConstraints & GenericParameterAttributes.ReferenceTypeConstraint) == GenericParameterAttributes.ReferenceTypeConstraint)
+                {
+                    if (parameterTypeInfo.IsValueType)
+                    {
+                        return false;
+                    }
+                }
+                if ((specialConstraints & GenericParameterAttributes.NotNullableValueTypeConstraint) == GenericParameterAttributes.NotNullableValueTypeConstraint)
+                {
+                    if (!parameterTypeInfo.IsValueType || parameterTypeInfo.IsGenericType && IsGenericTypeDefinedBy(parameter, typeof(Nullable<>)))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        private static bool IsGenericTypeDefinedBy(Type type, Type openGeneric)
+        {
+            return !type.ContainsGenericParameters && type.IsGenericType && type.GetGenericTypeDefinition() == openGeneric;
+        }
+
+        private static Type SubstituteGenericParameterConstraint(Type[] parameters, Type constraint)
+        {
+            return !constraint.IsGenericParameter ? constraint : parameters[constraint.GenericParameterPosition];
+        }
+
+        private static bool ParameterCompatibleWithTypeConstraint(Type parameter, Type constraint)
+        {
+            if (constraint.IsAssignableFrom(parameter))
+            {
+                return true;
+            }
+
+            if (ParameterEqualsConstraint(parameter, constraint))
+            {
+                return true;
+            }
+
+            if (parameter.BaseType != null && ParameterEqualsConstraint(parameter.BaseType, constraint))
+            {
+                return true;
+            }
+
+            foreach (var interfaceType in parameter.GetTypeInfo().ImplementedInterfaces)
+            {
+                if (ParameterEqualsConstraint(interfaceType, constraint))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool ParameterEqualsConstraint(Type parameter, Type constraint)
+        {
+            var genericArguments = parameter.GenericTypeArguments;
+            if (genericArguments.Length > 0 && constraint.IsGenericType)
+            {
+                var typeDefinition = constraint.GetGenericTypeDefinition();
+                if (typeDefinition.GetTypeInfo().GenericTypeParameters.Length == genericArguments.Length)
+                {
+                    var constraintArguments = constraint.GetTypeInfo().GenericTypeArguments;
+                    for (var i = 0; i < constraintArguments.Length; i++)
+                    {
+                        var constraintArgument = constraintArguments[i];
+                        if (!constraintArgument.IsGenericParameter && !constraintArgument.IsAssignableFrom(genericArguments[i]))
+                        {
+                            return false;
+                        }
+                    }
+
+                    Type genericType;
+                    try
+                    {
+                        genericType = typeDefinition.MakeGenericType(genericArguments);
+                    }
+                    catch (ArgumentException)
+                    {
+                        return false;
+                    }
+                    return genericType == parameter;
+                }
+            }
+            return false;
+        }
 
         public void Add(Type type, ServiceCallSite serviceCallSite)
         {

src/DependencyInjection/DI/test/Fakes/ClassInheritingAbstractClass.cs

@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Tests.Fakes
+{
+    public class ClassInheritingAbstractClass : AbstractClass
+    {
+
+    }
+
+    public class ClassAlsoInheritingAbstractClass : AbstractClass
+    {
+
+    }
+
+    public class ClassInheritingClassInheritingAbstractClass : AbstractClass
+    {
+
+    }
+}

src/DependencyInjection/DI/test/Fakes/ConstrainedFakeOpenGenericService.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
+
+namespace Microsoft.Extensions.DependencyInjection.Fakes
+{
+    public class ConstrainedFakeOpenGenericService<TVal> : IFakeOpenGenericService<TVal>
+        where TVal : PocoClass
+    {
+        public ConstrainedFakeOpenGenericService(TVal value)
+        {
+            Value = value;
+        }
+        public TVal Value { get; }
+    }
+}