Reworked the type inititialization flow. (#7953)

Author: michaelstaib

src/HotChocolate/ApolloFederation/src/ApolloFederation/FederationTypeInterceptor.cs

@@ -338,7 +338,7 @@ public override void OnBeforeCompleteType(
             definition);
     }
 
-    public override void OnAfterCompleteType(
+    public override void OnAfterMakeExecutable(
         ITypeCompletionContext completionContext,
         DefinitionBase definition)
     {
@@ -350,8 +350,6 @@ public override void OnAfterCompleteType(
         }
     }
 
-    internal override void OnAfterCreateSchemaInternal(IDescriptorContext context, ISchema schema) { }
-
     private void CompleteExternalFieldSetters(ObjectType type, ObjectTypeDefinition typeDef)
         => ExternalSetterExpressionHelper.TryAddExternalSetter(type, typeDef);
 

src/HotChocolate/ApolloFederation/src/ApolloFederation/Resolvers/ExternalSetterExpressionHelper.cs

@@ -31,7 +31,7 @@ public static void TryAddExternalSetter(ObjectType type, ObjectTypeDefinition ty
         foreach (var field in type.Fields)
         {
             if (field.Directives.ContainsDirective<ExternalDirective>() &&
-                field.Member is PropertyInfo { SetMethod: { }, } property)
+                field.Member is PropertyInfo { SetMethod: not null, } property)
             {
                 var expression = CreateTrySetValue(type.RuntimeType, property, field.Name);
                 (block ??= []).Add(expression);

src/HotChocolate/Core/src/Authorization/AuthorizationTypeInterceptor.cs

@@ -124,7 +124,7 @@ public override void OnBeforeCompleteType(
         }
     }
 
-    public override void OnAfterCompleteTypes()
+    public override void OnAfterMakeExecutable()
     {
         foreach (var type in _objectTypes)
         {

src/HotChocolate/Core/src/Types/Configuration/AggregateTypeInterceptor.cs

@@ -403,6 +403,102 @@ public override void OnAfterCompleteType(
         }
     }
 
+    public override void OnBeforeCompleteMetadata()
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnBeforeCompleteMetadata();
+        }
+    }
+
+    public override void OnAfterCompleteMetadata()
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnAfterCompleteMetadata();
+        }
+    }
+
+    public override void OnBeforeCompleteMetadata(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnBeforeCompleteMetadata(context, definition);
+        }
+    }
+
+    public override void OnAfterCompleteMetadata(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnAfterCompleteMetadata(context, definition);
+        }
+    }
+
+    public override void OnBeforeMakeExecutable()
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnBeforeMakeExecutable();
+        }
+    }
+
+    public override void OnAfterMakeExecutable()
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnAfterMakeExecutable();
+        }
+    }
+
+    public override void OnBeforeMakeExecutable(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnBeforeMakeExecutable(context, definition);
+        }
+    }
+
+    public override void OnAfterMakeExecutable(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+        ref var first = ref GetReference();
+        var length = _typeInterceptors.Length;
+
+        for (var i = 0; i < length; i++)
+        {
+            Unsafe.Add(ref first, i).OnAfterMakeExecutable(context, definition);
+        }
+    }
+
     public override void OnValidateType(
         ITypeSystemObjectContext validationContext,
         DefinitionBase definition)

src/HotChocolate/Core/src/Types/Configuration/TypeInitializer.cs

@@ -101,10 +101,19 @@ public void Initialize()
         // before we start completing types we will compile the resolvers.
         CompileResolvers();
 
-        // last we complete the types. Completing types means that we will assign all
-        // the fields resolving all missing parts and then making the types immutable.
+        // now we complete the types. This means at this point we are completing
+        // the type structure. Fields and arguments will be accessible after
+        // types are completed.
         CompleteTypes();
 
+        // next we are completing type system directives and feature metadata.
+        CompleteMetadata();
+
+        // before we can finalize the types and make the immutable we are going to make the
+        // types executable. This means that at this point we are taking the compiled resolvers
+        // and are compiling from them field middleware that are assigned to the output fields.
+        MakeExecutable();
+
         // at this point everything is completely initialized, and we just trigger a type
         // finalize to allow the type to clean up any initialization data structures.
         FinalizeTypes();
@@ -574,10 +583,13 @@ private void CompleteTypes()
     {
         _interceptor.OnBeforeCompleteTypes();
 
-        ProcessTypes(Completed, type => CompleteType(type));
+        if(ProcessTypes(Completed, type => CompleteType(type)))
+        {
+            _interceptor.OnTypesCompleted();
+        }
+
         EnsureNoErrors();
 
-        _interceptor.OnTypesCompleted();
         _interceptor.OnAfterCompleteTypes();
     }
 
@@ -597,6 +609,40 @@ internal bool CompleteType(RegisteredType registeredType)
         return true;
     }
 
+    private void CompleteMetadata()
+    {
+        _interceptor.OnBeforeCompleteMetadata();
+
+        foreach (var registeredType in _typeRegistry.Types)
+        {
+            if (!registeredType.IsExtension)
+            {
+                registeredType.Type.CompleteMetadata(registeredType);
+            }
+        }
+
+        EnsureNoErrors();
+
+        _interceptor.OnAfterCompleteMetadata();
+    }
+
+    private void MakeExecutable()
+    {
+        _interceptor.OnBeforeMakeExecutable();
+
+        foreach (var registeredType in _typeRegistry.Types)
+        {
+            if (!registeredType.IsExtension)
+            {
+                registeredType.Type.MakeExecutable(registeredType);
+            }
+        }
+
+        EnsureNoErrors();
+
+        _interceptor.OnAfterMakeExecutable();
+    }
+
     private void FinalizeTypes()
     {
         foreach (var registeredType in _typeRegistry.Types)
@@ -606,6 +652,8 @@ private void FinalizeTypes()
                 registeredType.Type.FinalizeType(registeredType);
             }
         }
+
+        EnsureNoErrors();
     }
 
     private bool ProcessTypes(

src/HotChocolate/Core/src/Types/Configuration/TypeInterceptor.cs

@@ -226,6 +226,9 @@ public virtual void OnAfterResolveRootType(
     {
     }
 
+    /// <summary>
+    /// This event is called after the type name is assigned.
+    /// </summary>
     public virtual void OnTypesCompletedName() { }
 
     /// <summary>
@@ -259,6 +262,11 @@ public virtual void OnBeforeCompleteMutationField(
     /// </summary>
     public virtual void OnBeforeCompleteTypes() { }
 
+    /// <summary>
+    /// This method is called after the types are completed.
+    /// </summary>
+    public virtual void OnTypesCompleted() { }
+
     /// <summary>
     /// This method is called after the types are completed.
     /// </summary>
@@ -294,6 +302,86 @@ public virtual void OnAfterCompleteType(
     {
     }
 
+    /// <summary>
+    /// This method is called before the metadata of all types are completed.
+    /// </summary>
+    public virtual void OnBeforeCompleteMetadata() { }
+
+    /// <summary>
+    /// This method is called after the metadata of all types are completed.
+    /// </summary>
+    public virtual void OnAfterCompleteMetadata() { }
+
+    /// <summary>
+    /// This event is called before the metadata of the type system member is fully completed.
+    /// </summary>
+    /// <param name="context">
+    /// The type completion context.
+    /// </param>
+    /// <param name="definition">
+    /// The type definition of the type system member.
+    /// </param>
+    public virtual void OnBeforeCompleteMetadata(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+    }
+
+    /// <summary>
+    /// This event is called after the metadata of the type system member was fully completed.
+    /// </summary>
+    /// <param name="context">
+    /// The type completion context.
+    /// </param>
+    /// <param name="definition">
+    /// The type definition of the type system member.
+    /// </param>
+    public virtual void OnAfterCompleteMetadata(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+    }
+
+    /// <summary>
+    /// This method is called before the types are made executable.
+    /// </summary>
+    public virtual void OnBeforeMakeExecutable() { }
+
+    /// <summary>
+    /// This method is called after the types are made executable.
+    /// </summary>
+    public virtual void OnAfterMakeExecutable() { }
+
+    /// <summary>
+    /// This event is called before the type system member is made executable.
+    /// </summary>
+    /// <param name="context">
+    /// The type completion context.
+    /// </param>
+    /// <param name="definition">
+    /// The type definition of the type system member.
+    /// </param>
+    public virtual void OnBeforeMakeExecutable(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+    }
+
+    /// <summary>
+    /// This event is called after the type system member is made executable.
+    /// </summary>
+    /// <param name="context">
+    /// The type completion context.
+    /// </param>
+    /// <param name="definition">
+    /// The type definition of the type system member.
+    /// </param>
+    public virtual void OnAfterMakeExecutable(
+        ITypeCompletionContext context,
+        DefinitionBase definition)
+    {
+    }
+
     /// <summary>
     /// This event is called after the type system member is fully completed and is
     /// intended to add validation logic. If the type is not valid throw a
@@ -311,8 +399,6 @@ public virtual void OnValidateType(
     {
     }
 
-    public virtual void OnTypesCompleted() { }
-
     // note: this hook is a legacy hook and will be removed once the new schema building API is completed.
     /// <summary>
     /// This hook is invoked after schema is fully created and gives access

src/HotChocolate/Core/src/Types/Internal/TypeDependencyHelper.cs

@@ -109,7 +109,7 @@ public static void CollectDependencies(
 
             if (field.Type is not null)
             {
-                dependencies.Add(new(field.Type, GetDefaultValueDependencyKind(field)));
+                dependencies.Add(new(field.Type));
             }
 
             CollectDirectiveDependencies(field, dependencies);
@@ -182,9 +182,7 @@ public static void CollectDependencies(
 
                 if (argument.Type is not null)
                 {
-                    dependencies.Add(new(
-                        argument.Type,
-                        GetDefaultValueDependencyKind(argument)));
+                    dependencies.Add(new(argument.Type));
                 }
             }
         }
@@ -334,16 +332,4 @@ public static void RegisterDependencies(
 
         CollectDependencies(definition, context.Dependencies);
     }
-
-    private static TypeDependencyFulfilled GetDefaultValueDependencyKind(
-        ArgumentDefinition argumentDefinition)
-    {
-        var hasDefaultValue =
-            argumentDefinition.DefaultValue is not null and not NullValueNode ||
-            argumentDefinition.RuntimeDefaultValue is not null;
-
-        return hasDefaultValue
-            ? Completed
-            : Default;
-    }
 }

src/HotChocolate/Core/src/Types/InvalidSchemaCoordinateException.cs

@@ -7,6 +7,7 @@ namespace HotChocolate;
 /// <see cref="InvalidSchemaCoordinateException.Coordinate"/>
 /// could not be resolved.
 /// </summary>
+#pragma warning disable RCS1194
 public class InvalidSchemaCoordinateException : Exception
 {
     /// <summary>
@@ -26,3 +27,4 @@ public InvalidSchemaCoordinateException(string message, SchemaCoordinate coordin
     /// <value></value>
     public SchemaCoordinate Coordinate { get; }
 }
+#pragma warning restore RCS1194