Introduced Priority Queue to Type Discovery (#8955)

michaelstaib · web-flow · commit 6f69bfa8843a · 2025-12-01T00:14:34.000+01:00
diff --git a/src/HotChocolate/Core/src/Types/Configuration/BuiltInDirectiveTypeReferences.cs b/src/HotChocolate/Core/src/Types/Configuration/BuiltInDirectiveTypeReferences.cs
@@ -0,0 +1,50 @@
+using HotChocolate.Types;
+using HotChocolate.Types.Descriptors;
+
+namespace HotChocolate.Configuration;
+
+internal static class BuiltInDirectiveTypeReferences
+{
+    internal static void Enqueue(
+        PriorityQueue<TypeReference, (TypeReferenceStrength, int)> backlog,
+        IDescriptorContext context,
+        ref int nextIndex)
+    {
+        var typeInspector = context.TypeInspector;
+
+        if (context.Options.EnableOneOf)
+        {
+            EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(OneOfDirectiveType)), nextIndex++);
+        }
+
+        if (context.Options.EnableDefer)
+        {
+            EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(DeferDirectiveType)), nextIndex++);
+        }
+
+        if (context.Options.EnableStream)
+        {
+            EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(StreamDirectiveType)), nextIndex++);
+        }
+
+        if (context.Options.EnableSemanticNonNull)
+        {
+            EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(SemanticNonNullDirective)), nextIndex++);
+        }
+
+        if (context.Options.EnableTag)
+        {
+            EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(Tag)), nextIndex++);
+        }
+
+        EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(SkipDirectiveType)), nextIndex++);
+        EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(IncludeDirectiveType)), nextIndex++);
+        EnqueueTypeRef(backlog, typeInspector.GetTypeRef(typeof(DeprecatedDirectiveType)), nextIndex++);
+
+        static void EnqueueTypeRef(
+            PriorityQueue<TypeReference, (TypeReferenceStrength, int)> backlog,
+            TypeReference typeRef,
+            int index)
+            => backlog.Enqueue(typeRef, (TypeReferenceStrength.System, index));
+    }
+}
diff --git a/src/HotChocolate/Core/src/Types/Configuration/IntrospectionTypeReferences.cs b/src/HotChocolate/Core/src/Types/Configuration/IntrospectionTypeReferences.cs
@@ -0,0 +1,34 @@
+using HotChocolate.Types.Descriptors;
+using HotChocolate.Types.Introspection;
+
+namespace HotChocolate.Configuration;
+
+internal static class IntrospectionTypeReferences
+{
+    internal static void Enqueue(
+        PriorityQueue<TypeReference, (TypeReferenceStrength, int)> backlog,
+        IDescriptorContext context,
+        ref int nextIndex)
+    {
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__Directive)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__DirectiveLocation)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__EnumValue)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__Field)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__InputValue)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__Schema)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__Type)), nextIndex++);
+        EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__TypeKind)), nextIndex++);
+
+        if (context.Options.EnableDirectiveIntrospection)
+        {
+            EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__AppliedDirective)), nextIndex++);
+            EnqueueTypeRef(backlog, context.TypeInspector.GetTypeRef(typeof(__DirectiveArgument)), nextIndex++);
+        }
+
+        static void EnqueueTypeRef(
+            PriorityQueue<TypeReference, (TypeReferenceStrength, int)> backlog,
+            TypeReference typeRef,
+            int index)
+            => backlog.Enqueue(typeRef, (TypeReferenceStrength.System, index));
+    }
+}
diff --git a/src/HotChocolate/Core/src/Types/Configuration/TypeDiscoverer.cs b/src/HotChocolate/Core/src/Types/Configuration/TypeDiscoverer.cs
@@ -7,7 +7,6 @@ namespace HotChocolate.Configuration;
 
 internal sealed class TypeDiscoverer
 {
-    private readonly List<TypeReference> _unregistered = [];
     private readonly List<ISchemaError> _errors = [];
     private readonly List<TypeReference> _resolved = [];
     private readonly IDescriptorContext _context;
@@ -16,6 +15,9 @@ internal sealed class TypeDiscoverer
     private readonly ITypeRegistrarHandler[] _handlers;
     private readonly TypeInterceptor _interceptor;
 
+    private readonly PriorityQueue<TypeReference, (TypeReferenceStrength, int)> _unregistered = new();
+    private int _nextTypeRefIndex;
+
     public TypeDiscoverer(
         IDescriptorContext context,
         TypeRegistry typeRegistry,
@@ -35,53 +37,41 @@ public TypeDiscoverer(
 
         if (includeSystemTypes)
         {
-            _unregistered.AddRange(IntrospectionTypes.CreateReferences(context));
-            _unregistered.AddRange(Directives.CreateReferences(context));
+            IntrospectionTypeReferences.Enqueue(_unregistered, context, ref _nextTypeRefIndex);
+            BuiltInDirectiveTypeReferences.Enqueue(_unregistered, context, ref _nextTypeRefIndex);
         }
 
-        var first = new List<TypeReference>();
-        var second = new List<TypeReference>();
-        var third = new List<TypeReference>();
-        var fourth = new List<TypeReference>();
-
         foreach (var typeRef in typeRegistry.GetTypeRefs().Concat(initialTypes.Distinct()))
         {
             switch (typeRef)
             {
                 case ExtendedTypeReference { Type.IsSchemaType: true } extendedTypeRef:
-                    if (typeof(ScalarType).IsAssignableFrom(extendedTypeRef.Type.Type))
-                    {
-                        first.Add(typeRef);
-                    }
-                    else
-                    {
-                        second.Add(typeRef);
-                    }
+                    _unregistered.Enqueue(
+                        typeRef,
+                        (typeof(ScalarType).IsAssignableFrom(extendedTypeRef.Type.Type)
+                            ? TypeReferenceStrength.VeryStrong
+                            : TypeReferenceStrength.Strong,
+                            _nextTypeRefIndex++));
                     break;
 
                 case ExtendedTypeReference:
-                    third.Add(typeRef);
+                    _unregistered.Enqueue(typeRef, (TypeReferenceStrength.Weak, _nextTypeRefIndex++));
                     break;
 
                 case SchemaTypeReference { Type: ScalarType }:
-                    first.Add(typeRef);
+                    _unregistered.Enqueue(typeRef, (TypeReferenceStrength.VeryStrong, _nextTypeRefIndex++));
                     break;
 
                 case SchemaTypeReference:
-                    second.Add(typeRef);
+                    _unregistered.Enqueue(typeRef, (TypeReferenceStrength.Strong, _nextTypeRefIndex++));
                     break;
 
                 default:
-                    fourth.Add(typeRef);
+                    _unregistered.Enqueue(typeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));
                     break;
             }
         }
 
-        _unregistered.AddRange(first);
-        _unregistered.AddRange(second);
-        _unregistered.AddRange(third);
-        _unregistered.AddRange(fourth);
-
         _typeRegistrar = new TypeRegistrar(context, typeRegistry, typeLookup, interceptor);
 
         _handlers =
@@ -137,7 +127,7 @@ public IReadOnlyList<ISchemaError> DiscoverTypes()
             {
                 if (processed.Add(typeReference))
                 {
-                    _unregistered.Add(typeReference);
+                    _unregistered.Enqueue(typeReference, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));
                 }
             }
 
@@ -161,18 +151,18 @@ private void RegisterTypes()
     {
         while (_unregistered.Count > 0)
         {
-            foreach (var typeRef in _unregistered)
+            while (_unregistered.TryDequeue(out var typeRef, out _))
             {
                 var index = (int)typeRef.Kind;
-
                 if (_handlers.Length > index)
                 {
                     _handlers[index].Handle(_typeRegistrar, typeRef);
                 }
             }
 
-            _unregistered.Clear();
-            _unregistered.AddRange(_typeRegistrar.GetUnhandled());
+            _unregistered.EnqueueRange(
+                _typeRegistrar.GetUnhandled().Select(
+                    typeRef => (t: typeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++))));
         }
     }
 
@@ -188,7 +178,7 @@ private bool TryInferTypes()
                 && _typeRegistry.RuntimeTypeRefs.TryGetValue(extendedTypeRef, out var typeReference))
             {
                 inferred = true;
-                _unregistered.Add(typeReference);
+                _unregistered.Enqueue(typeReference, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));
                 _resolved.Add(unresolvedTypeRef);
                 continue;
             }
@@ -201,11 +191,11 @@ private bool TryInferTypes()
 
                 foreach (var schemaTypeRef in schemaTypeRefs)
                 {
-                    _unregistered.Add(schemaTypeRef);
+                    _unregistered.Enqueue(schemaTypeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));
 
                     if (unresolvedTypeRef is ExtendedTypeReference typeRef)
                     {
-                        // we normalize the type context so that we can correctly lookup
+                        // we normalize the type context so that we can correctly look up
                         // if a type is already registered.
                         typeRef = typeRef.WithContext(schemaTypeRef.Context);
                         _typeRegistry.TryRegister(typeRef, schemaTypeRef);
@@ -263,7 +253,7 @@ private void CollectErrors()
                 {
                     builder
                         .SetTypeSystemObject(types[0].Type)
-                        .SetExtension("involvedTypes", types.Select(t => t.Type).ToList());
+                        .SetExtension("involvedTypes", types.ConvertAll(t => t.Type));
                 }
 
                 _errors.Add(builder.Build());
diff --git a/src/HotChocolate/Core/src/Types/Configuration/TypeReferenceStrength.cs b/src/HotChocolate/Core/src/Types/Configuration/TypeReferenceStrength.cs
@@ -0,0 +1,10 @@
+namespace HotChocolate.Configuration;
+
+internal enum TypeReferenceStrength
+{
+    System = 0,
+    VeryStrong = 1,
+    Strong = 2,
+    Weak = 3,
+    VeryWeak = 4
+}
diff --git a/src/HotChocolate/Core/src/Types/Types/Directives/Directives.cs b/src/HotChocolate/Core/src/Types/Types/Directives/Directives.cs
diff --git a/src/HotChocolate/Core/src/Types/Types/Introspection/IntrospectionTypes.cs b/src/HotChocolate/Core/src/Types/Types/Introspection/IntrospectionTypes.cs
diff --git a/src/HotChocolate/Spatial/test/Data.Filters.SqlServer.Tests/PostgisConfig.cs b/src/HotChocolate/Spatial/test/Data.Filters.SqlServer.Tests/PostgisConfig.cs
@@ -9,7 +9,7 @@ public override void Configure(ContainerResourceBuilder builder)
         builder
             .WaitTimeout(120)
             .Name("postgis")
-            .Image("postgis/postgis:latest")
+            .Image("postgis/postgis:16-3.4-alpine")
             .Username("postgis")
             .Password(Guid.NewGuid().ToString("N")[12..])
             .InternalPort(5432);

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@ namespace HotChocolate.Configuration;`
`7`	`7`
`8`	`8`	`internal sealed class TypeDiscoverer`
`9`	`9`	`{`
`10`		`- private readonly List<TypeReference> _unregistered = [];`
`11`	`10`	`private readonly List<ISchemaError> _errors = [];`
`12`	`11`	`private readonly List<TypeReference> _resolved = [];`
`13`	`12`	`private readonly IDescriptorContext _context;`
`@@ -16,6 +15,9 @@ internal sealed class TypeDiscoverer`
`16`	`15`	`private readonly ITypeRegistrarHandler[] _handlers;`
`17`	`16`	`private readonly TypeInterceptor _interceptor;`
`18`	`17`
	`18`	`+ private readonly PriorityQueue<TypeReference, (TypeReferenceStrength, int)> _unregistered = new();`
	`19`	`+ private int _nextTypeRefIndex;`
	`20`	`+`
`19`	`21`	`public TypeDiscoverer(`
`20`	`22`	`IDescriptorContext context,`
`21`	`23`	`TypeRegistry typeRegistry,`
`@@ -35,53 +37,41 @@ public TypeDiscoverer(`
`35`	`37`
`36`	`38`	`if (includeSystemTypes)`
`37`	`39`	`{`
`38`		`- _unregistered.AddRange(IntrospectionTypes.CreateReferences(context));`
`39`		`- _unregistered.AddRange(Directives.CreateReferences(context));`
	`40`	`+ IntrospectionTypeReferences.Enqueue(_unregistered, context, ref _nextTypeRefIndex);`
	`41`	`+ BuiltInDirectiveTypeReferences.Enqueue(_unregistered, context, ref _nextTypeRefIndex);`
`40`	`42`	`}`
`41`	`43`
`42`		`- var first = new List<TypeReference>();`
`43`		`- var second = new List<TypeReference>();`
`44`		`- var third = new List<TypeReference>();`
`45`		`- var fourth = new List<TypeReference>();`
`46`		`-`
`47`	`44`	`foreach (var typeRef in typeRegistry.GetTypeRefs().Concat(initialTypes.Distinct()))`
`48`	`45`	`{`
`49`	`46`	`switch (typeRef)`
`50`	`47`	`{`
`51`	`48`	`case ExtendedTypeReference { Type.IsSchemaType: true } extendedTypeRef:`
`52`		`- if (typeof(ScalarType).IsAssignableFrom(extendedTypeRef.Type.Type))`
`53`		`- {`
`54`		`- first.Add(typeRef);`
`55`		`- }`
`56`		`- else`
`57`		`- {`
`58`		`- second.Add(typeRef);`
`59`		`- }`
	`49`	`+ _unregistered.Enqueue(`
	`50`	`+ typeRef,`
	`51`	`+ (typeof(ScalarType).IsAssignableFrom(extendedTypeRef.Type.Type)`
	`52`	`+ ? TypeReferenceStrength.VeryStrong`
	`53`	`+ : TypeReferenceStrength.Strong,`
	`54`	`+ _nextTypeRefIndex++));`
`60`	`55`	`break;`
`61`	`56`
`62`	`57`	`case ExtendedTypeReference:`
`63`		`- third.Add(typeRef);`
	`58`	`+ _unregistered.Enqueue(typeRef, (TypeReferenceStrength.Weak, _nextTypeRefIndex++));`
`64`	`59`	`break;`
`65`	`60`
`66`	`61`	`case SchemaTypeReference { Type: ScalarType }:`
`67`		`- first.Add(typeRef);`
	`62`	`+ _unregistered.Enqueue(typeRef, (TypeReferenceStrength.VeryStrong, _nextTypeRefIndex++));`
`68`	`63`	`break;`
`69`	`64`
`70`	`65`	`case SchemaTypeReference:`
`71`		`- second.Add(typeRef);`
	`66`	`+ _unregistered.Enqueue(typeRef, (TypeReferenceStrength.Strong, _nextTypeRefIndex++));`
`72`	`67`	`break;`
`73`	`68`
`74`	`69`	`default:`
`75`		`- fourth.Add(typeRef);`
	`70`	`+ _unregistered.Enqueue(typeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));`
`76`	`71`	`break;`
`77`	`72`	`}`
`78`	`73`	`}`
`79`	`74`
`80`		`- _unregistered.AddRange(first);`
`81`		`- _unregistered.AddRange(second);`
`82`		`- _unregistered.AddRange(third);`
`83`		`- _unregistered.AddRange(fourth);`
`84`		`-`
`85`	`75`	`_typeRegistrar = new TypeRegistrar(context, typeRegistry, typeLookup, interceptor);`
`86`	`76`
`87`	`77`	`_handlers =`
`@@ -137,7 +127,7 @@ public IReadOnlyList<ISchemaError> DiscoverTypes()`
`137`	`127`	`{`
`138`	`128`	`if (processed.Add(typeReference))`
`139`	`129`	`{`
`140`		`- _unregistered.Add(typeReference);`
	`130`	`+ _unregistered.Enqueue(typeReference, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));`
`141`	`131`	`}`
`142`	`132`	`}`
`143`	`133`
`@@ -161,18 +151,18 @@ private void RegisterTypes()`
`161`	`151`	`{`
`162`	`152`	`while (_unregistered.Count > 0)`
`163`	`153`	`{`
`164`		`- foreach (var typeRef in _unregistered)`
	`154`	`+ while (_unregistered.TryDequeue(out var typeRef, out _))`
`165`	`155`	`{`
`166`	`156`	`var index = (int)typeRef.Kind;`
`167`		`-`
`168`	`157`	`if (_handlers.Length > index)`
`169`	`158`	`{`
`170`	`159`	`_handlers[index].Handle(_typeRegistrar, typeRef);`
`171`	`160`	`}`
`172`	`161`	`}`
`173`	`162`
`174`		`- _unregistered.Clear();`
`175`		`- _unregistered.AddRange(_typeRegistrar.GetUnhandled());`
	`163`	`+ _unregistered.EnqueueRange(`
	`164`	`+ _typeRegistrar.GetUnhandled().Select(`
	`165`	`+ typeRef => (t: typeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++))));`
`176`	`166`	`}`
`177`	`167`	`}`
`178`	`168`
`@@ -188,7 +178,7 @@ private bool TryInferTypes()`
`188`	`178`	`&& _typeRegistry.RuntimeTypeRefs.TryGetValue(extendedTypeRef, out var typeReference))`
`189`	`179`	`{`
`190`	`180`	`inferred = true;`
`191`		`- _unregistered.Add(typeReference);`
	`181`	`+ _unregistered.Enqueue(typeReference, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));`
`192`	`182`	`_resolved.Add(unresolvedTypeRef);`
`193`	`183`	`continue;`
`194`	`184`	`}`
`@@ -201,11 +191,11 @@ private bool TryInferTypes()`
`201`	`191`
`202`	`192`	`foreach (var schemaTypeRef in schemaTypeRefs)`
`203`	`193`	`{`
`204`		`- _unregistered.Add(schemaTypeRef);`
	`194`	`+ _unregistered.Enqueue(schemaTypeRef, (TypeReferenceStrength.VeryWeak, _nextTypeRefIndex++));`
`205`	`195`
`206`	`196`	`if (unresolvedTypeRef is ExtendedTypeReference typeRef)`
`207`	`197`	`{`
`208`		`- // we normalize the type context so that we can correctly lookup`
	`198`	`+ // we normalize the type context so that we can correctly look up`
`209`	`199`	`// if a type is already registered.`
`210`	`200`	`typeRef = typeRef.WithContext(schemaTypeRef.Context);`
`211`	`201`	`_typeRegistry.TryRegister(typeRef, schemaTypeRef);`
`@@ -263,7 +253,7 @@ private void CollectErrors()`
`263`	`253`	`{`
`264`	`254`	`builder`
`265`	`255`	`.SetTypeSystemObject(types[0].Type)`
`266`		`- .SetExtension("involvedTypes", types.Select(t => t.Type).ToList());`
	`256`	`+ .SetExtension("involvedTypes", types.ConvertAll(t => t.Type));`
`267`	`257`	`}`
`268`	`258`
`269`	`259`	`_errors.Add(builder.Build());`