Fixed: The type discoverer ignored a type if it was already discovered in another context. (#350)

Author: michaelstaib

src/Types.Tests/Discovery/SchemaTypeDiscoveryTests.cs

@@ -19,10 +19,16 @@ public void DiscoverInputArgumentTypes()
             });
 
             // assert
-            IInputType fooInput = schema.GetType<INamedInputType>("FooInput");
+            var foo = schema.GetType<INamedOutputType>("Foo");
+            Assert.NotNull(foo);
+
+            var bar = schema.GetType<INamedOutputType>("Bar");
+            Assert.NotNull(foo);
+
+            var fooInput = schema.GetType<INamedInputType>("FooInput");
             Assert.NotNull(fooInput);
 
-            IInputType barInput = schema.GetType<INamedInputType>("BarInput");
+            var barInput = schema.GetType<INamedInputType>("BarInput");
             Assert.NotNull(barInput);
         }
 
@@ -129,12 +135,14 @@ public void InferCustomScalarTypes()
             var fooByte = schema.GetType<ObjectType>("FooByte");
             Assert.NotNull(fooByte);
 
-            ObjectField field =  fooByte.Fields["bar"];
+            ObjectField field = fooByte.Fields["bar"];
             Assert.Equal("ByteArray", field.Type.NamedType().Name);
         }
 
         public class QueryFieldArgument
         {
+            public Bar Bar { get; }
+
             public Foo GetFoo(Foo foo)
             {
                 return foo;

src/Types.Tests/Types/UuidTypeTests.cs

@@ -11,11 +11,11 @@ public void Serialize_Guid()
         {
             // arrange
             var uuidType = new UuidType();
-            Guid guid = Guid.NewGuid();
-            string expectedValue = guid.ToString("N");
+            var guid = Guid.NewGuid();
+            var expectedValue = guid.ToString("N");
 
             // act
-            string serializedValue = (string)uuidType.Serialize(guid);
+            var serializedValue = (string)uuidType.Serialize(guid);
 
             // assert
             Assert.Equal(expectedValue, serializedValue);
@@ -28,7 +28,7 @@ public void Serialize_Null()
             var uuidType = new UuidType();
 
             // act
-            object serializedValue = uuidType.Serialize(null);
+            var serializedValue = uuidType.Serialize(null);
 
             // assert
             Assert.Null(serializedValue);
@@ -39,11 +39,11 @@ public void ParseLiteral_StringValueNode()
         {
             // arrange
             var uuidType = new UuidType();
-            Guid expected = Guid.NewGuid();
+            var expected = Guid.NewGuid();
             var literal = new StringValueNode(expected.ToString());
 
             // act
-            Guid actual = (Guid)uuidType
+            var actual = (Guid)uuidType
                 .ParseLiteral(literal);
 
             // assert
@@ -58,7 +58,7 @@ public void ParseLiteral_NullValueNode()
             NullValueNode literal = NullValueNode.Default;
 
             // act
-            object value = uuidType.ParseLiteral(literal);
+            var value = uuidType.ParseLiteral(literal);
 
             // assert
             Assert.Null(value);
@@ -69,11 +69,11 @@ public void ParseValue_Guid()
         {
             // arrange
             var uuidType = new UuidType();
-            Guid expected = Guid.NewGuid();
-            string expectedLiteralValue = expected.ToString("N");
+            var expected = Guid.NewGuid();
+            var expectedLiteralValue = expected.ToString("N");
 
             // act
-            StringValueNode stringLiteral =
+            var stringLiteral =
                 (StringValueNode)uuidType.ParseValue(expected);
 
             // assert

src/Types/Configuration/TypeInitializers/TypeRegistrar.cs

@@ -88,7 +88,8 @@ private void ProcessBatch(
 
         private void ProcessUnresolvedTypes(ITypeRegistry typeRegistry)
         {
-            foreach (TypeReference unresolvedType in typeRegistry.GetUnresolvedTypes())
+            foreach (TypeReference unresolvedType in 
+                typeRegistry.GetUnresolvedTypes())
             {
                 if (IsObjectType(unresolvedType))
                 {
@@ -107,7 +108,7 @@ private void ProcessUnresolvedTypes(ITypeRegistry typeRegistry)
                     typeRegistry.RegisterType(
                         new TypeReference(typeof(EnumType<>)
                             .MakeGenericType(unresolvedType.ClrType)));
-                }
+                }     
             }
         }
 

src/Types/Configuration/TypeRegistry.GetType.cs

@@ -67,7 +67,11 @@ private bool TryGetTypeFromClrType<T>(
             TypeContext context,
             out T type)
         {
-            if (TryGetTypeFromClrType(clrType, context, t => t, out type))
+            if (TryGetTypeFromClrType(
+                DotNetTypeInfoFactory.Unwrap(clrType),
+                context,
+                t => t,
+                out type))
             {
                 return true;
             }
@@ -233,15 +237,18 @@ public IEnumerable<TypeReference> GetUnresolvedTypes()
             return _unresolvedTypes;
         }
 
-        private bool IsTypeResolved(TypeReference unresolvedType)
+        private bool IsTypeResolved(TypeReference typeReference) =>
+            IsTypeResolved(typeReference.ClrType, typeReference.Context);
+
+
+        private bool IsTypeResolved(Type clrType, TypeContext context)
         {
-            if (_clrTypes.TryGetValue(
-                unresolvedType.ClrType,
+            if (_clrTypes.TryGetValue(clrType,
                 out HashSet<NameString> associated))
             {
                 foreach (NameString name in associated)
                 {
-                    switch (unresolvedType.Context)
+                    switch (context)
                     {
                         case TypeContext.Input:
                             if (IsInputType(name))

src/Types/Configuration/TypeRegistry.RegisterType.cs

@@ -47,11 +47,11 @@ private void RegisterType(Type type, TypeContext context)
             {
                 if (typeof(INamedType).IsAssignableFrom(typeInfo.ClrType))
                 {
-                    INamedType namedType = (INamedType)_serviceFactory
+                    var namedType = (INamedType)_serviceFactory
                         .CreateInstance(typeInfo.ClrType);
                     TryUpdateNamedType(namedType);
                 }
-                else if (!_clrTypes.ContainsKey(typeInfo.ClrType))
+                else if (!IsTypeResolved(typeInfo.ClrType, context))
                 {
                     _unresolvedTypes.Add(
                         new TypeReference(typeInfo.ClrType, context));

src/Types/Configuration/TypeRegistry.cs

@@ -25,12 +25,8 @@ internal partial class TypeRegistry
 
         public TypeRegistry(ServiceFactory serviceFactory)
         {
-            if (serviceFactory == null)
-            {
-                throw new ArgumentNullException(nameof(serviceFactory));
-            }
-
-            _serviceFactory = serviceFactory;
+            _serviceFactory = serviceFactory 
+                ?? throw new ArgumentNullException(nameof(serviceFactory));
         }
 
         public void CompleteRegistartion()

src/Types/Resolvers/FieldReferenceBase.cs

@@ -1,5 +1,4 @@
 using System;
-using HotChocolate.Utilities;
 
 namespace HotChocolate.Resolvers
 {

src/Types/Types/Descriptors/InputObjectTypeDescriptor.cs

@@ -102,7 +102,8 @@ public InputObjectTypeDescriptor(Type clrType)
             // this convention will fix most type colisions where the
             // .net type is and input and an output type.
             // It is still possible to opt out via the descriptor.Name("Foo").
-            if (!ObjectDescription.Name.EndsWith("Input"))
+            if (!ObjectDescription.Name.EndsWith("Input",
+                    StringComparison.Ordinal))
             {
                 ObjectDescription.Name = ObjectDescription.Name + "Input";
             }

src/Types/Types/FieldBase.cs

@@ -63,6 +63,7 @@ protected override void OnRegisterDependencies(
 
             if (TypeReference != null)
             {
+                string s = TypeReference.ToString();
                 context.RegisterType(TypeReference);
             }
         }

src/Types/Types/TypeReference.cs

@@ -71,21 +71,12 @@ public override int GetHashCode()
                     return (ClrType.GetHashCode() * 397)
                         ^ (Context.GetHashCode() * 97);
                 }
-                else
-                {
-                    return Type.GetHashCode();
-                }
+                return Type.GetHashCode();
             }
         }
 
-        public override string ToString()
-        {
-            if (ClrType == null)
-            {
-                return Type.ToString();
-            }
-            return ClrType.GetTypeName();
-        }
+        public override string ToString() =>
+            ClrType == null ? Type.ToString() : ClrType.GetTypeName();
     }
 
     internal static class TypeReferenceExtensions