[WIP] GDExtension bindings generator

raulsntos · raulsntos · commit 73b91532c017 · 2026-05-18T20:50:04.000+02:00
diff --git a/src/Godot.Bindings/Core/GodotObject.cs b/src/Godot.Bindings/Core/GodotObject.cs
@@ -107,7 +107,7 @@ private unsafe GodotObject(GodotObjectCreationOptions options)
             GodotBridge.GDExtensionInterface.object_set_instance((void*)NativePtr, &extensionClassName, (void*)gcHandlePtr);
         }
 
-        if (!options.InstanceBindingAlreadyBound)
+        if (!options.InstanceBindingAlreadyBound && !IsGDExtensionDefinedType())
         {
             var bindingCallbacks = GDExtensionInstanceBindingCallbacks.Default;
             if (!IsUserDefinedType())
@@ -148,6 +148,13 @@ bool IsUserDefinedType()
             // If this type is not defined in this assembly, it must be a user-defined type.
             return GetType().Assembly != typeof(GodotObject).Assembly;
         }
+
+        bool IsGDExtensionDefinedType()
+        {
+            // If this type is defined in the GDExtensionBindings assembly,
+            // it must be a type defined by a GDExtension that we generated bindings for.
+            return GetType().Assembly.GetName().Name == "GDExtensionBindings";
+        }
     }
 
     /// <summary>
diff --git a/src/Godot.Bindings/Godot.Bindings.csproj b/src/Godot.Bindings/Godot.Bindings.csproj
@@ -27,6 +27,11 @@
     <InternalsVisibleTo Include="Godot.Bindings.IntegrationTests.TestGame" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- The generated GDExtension bindings need to use internal API. -->
+    <InternalsVisibleTo Include="GDExtensionBindings" />
+  </ItemGroup>
+
   <!-- Reference the project that contains the MSBuild task to ensure the build order is correct. -->
   <ItemGroup>
     <ProjectReference Include="..\Godot.BindingsGeneration.Tasks\Godot.BindingsGeneration.Tasks.csproj" ReferenceOutputAssembly="false" />
diff --git a/src/Godot.Bindings/NativeInterop/InteropUtils.cs b/src/Godot.Bindings/NativeInterop/InteropUtils.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Frozen;
+using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using Godot.Bridge;
 
@@ -25,6 +26,8 @@ public unsafe void Invoke([DynamicallyAccessedMembers(DynamicallyAccessedMemberT
 
     private static FrozenDictionary<StringName, GDExtensionInstanceBindingCallbacks> _bindingCallbacks;
 
+    private static ConcurrentDictionary<StringName, GDExtensionInstanceBindingCallbacks> _extensionBindingCallbacks { get; } = new(StringNameEqualityComparer.Default);
+
     private static FrozenDictionary<StringName, RegisterVirtualOverrideHandler> _registerVirtualOverridesHelpers;
 
     static InteropUtils()
@@ -39,6 +42,11 @@ internal static bool TryGetBindingCallbacks(StringName className, [NotNullWhen(t
             return true;
         }
 
+        if (_extensionBindingCallbacks.TryGetValue(className, out bindingCallbacks))
+        {
+            return true;
+        }
+
         return false;
     }
 
@@ -50,9 +58,25 @@ internal static bool TryGetBindingCallbacks(NativeGodotStringName className, [No
             return true;
         }
 
+        var extensionBindingCallbacksLookup = _extensionBindingCallbacks.GetAlternateLookup<NativeGodotStringName>();
+        if (extensionBindingCallbacksLookup.TryGetValue(className, out bindingCallbacks))
+        {
+            return true;
+        }
+
         return false;
     }
 
+    internal static void RegisterExtensionBindingCallbacks(StringName extensionClassName, GDExtensionInstanceBindingCallbacks bindingCallbacks)
+    {
+        if (_bindingCallbacks.ContainsKey(extensionClassName) || _extensionBindingCallbacks.ContainsKey(extensionClassName))
+        {
+            throw new InvalidOperationException($"Binding callbacks for '{extensionClassName}' are already registered.");
+        }
+
+        _extensionBindingCallbacks[extensionClassName] = bindingCallbacks;
+    }
+
     internal static void RegisterVirtualOverrides([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type type, ClassRegistrationContext context)
     {
         // It's fine if there is no helper for this class, it may just mean there are no virtual overrides to register.
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/BuiltInClassesBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/BuiltInClassesBindingsDataCollector.cs
@@ -18,6 +18,12 @@ internal sealed class BuiltInClassesBindingsDataCollector : BindingsDataCollecto
 
     public override void Initialize(BindingsData.CollectionContext context)
     {
+        if (context.IsExtension)
+        {
+            // Built-in classes are only generated for the core API, not for GDExtensions.
+            return;
+        }
+
         foreach (var engineClass in context.Api.BuiltInClasses)
         {
             if (!ShouldGenerateBuiltInClass(engineClass.Name) && !ShouldGenerateBuiltInClassHelpers(engineClass.Name))
@@ -62,6 +68,12 @@ void RegisterBuiltInType(string engineTypeName, TypeInfo type)
 
     public override void Populate(BindingsData.CollectionContext context)
     {
+        if (context.IsExtension)
+        {
+            // Built-in classes are only generated for the core API, not for GDExtensions.
+            return;
+        }
+
         foreach (var engineClass in context.Api.BuiltInClasses)
         {
             if (!_builtinClasses.TryGetValue(engineClass.Name, out var type))
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/EngineClassesBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/EngineClassesBindingsDataCollector.cs
@@ -87,6 +87,53 @@ public override void Populate(BindingsData.CollectionContext context)
             PopulateEngineClassEnumsAndConstants(context, engineClass);
         }
 
+        if (context.IsExtension)
+        {
+            // InteropUtils is only generated for the core API, not for GDExtensions.
+            // Instead, we generate a module initializer in each for each GDExtension that populates InteropUtils.
+            context.AddGeneratedType("NativeInterop/InteropUtils.cs", new TypeInfo("InteropUtils", context.Options.Namespace)
+            {
+                VisibilityAttributes = VisibilityAttributes.Assembly,
+                TypeAttributes = TypeAttributes.ReferenceType,
+                IsStatic = true,
+                DeclaredFields =
+                {
+                    new FieldInfo("_isInitialized", KnownTypes.SystemBoolean)
+                    {
+                        VisibilityAttributes = VisibilityAttributes.Private,
+                        IsStatic = true,
+                    },
+                },
+                DeclaredMethods =
+                {
+                    new MethodInfo("EnsureHelpersInitialized")
+                    {
+                        VisibilityAttributes = VisibilityAttributes.Assembly,
+                        Attributes =
+                        {
+                            "[global::System.Runtime.CompilerServices.ModuleInitializer]",
+                        },
+                        IsStatic = true,
+                        Body = MethodBody.Create(writer =>
+                        {
+                            writer.WriteLine("if (global::System.Threading.Interlocked.Exchange(ref _isInitialized, true))");
+                            writer.WriteLine("{");
+                            writer.WriteLine("    return;");
+                            writer.WriteLine("}");
+
+                            foreach (var engineClass in context.Api.Classes)
+                            {
+                                var type = context.TypeDB.GetTypeFromEngineName(engineClass.Name);
+
+                                writer.WriteLine($"global::Godot.NativeInterop.InteropUtils.RegisterExtensionBindingCallbacks({type.FullNameWithGlobal}.NativeName, {type.FullNameWithGlobal}.BindingCallbacks);");
+                            }
+                        }),
+                    },
+                }
+            });
+            return;
+        }
+
         // Generate method in InteropUtils to initialize the dictionary with helpers
         // used to access constructors and static methods for a Godot class from the
         // native class name.
@@ -575,6 +622,10 @@ private static void PopulateEngineClassSignals(BindingsData.CollectionContext co
         foreach (var engineSignal in engineClass.Signals)
         {
             string eventName = NamingUtils.SnakeToPascalCase(engineSignal.Name);
+            if (context.IsExtension)
+            {
+                eventName = $"{eventName}Signal";
+            }
 
             List<TypeInfo> signalParameterTypes = [];
             List<ParameterInfo> signalParameters = [];
@@ -909,15 +960,19 @@ void AddMemberNameOrRename(HashSet<string> usedNames, MemberInfo member, string
 
                 foreach (var engineSignal in engineClass.Signals)
                 {
-                    AddCachedStringName(signalNamesType, engineSignal.Name);
+                    AddCachedStringName(signalNamesType, engineSignal.Name, context.IsExtension ? "Signal" : null);
                 }
 
                 type.NestedTypes.Add(signalNamesType);
             }
 
-            static void AddCachedStringName(TypeInfo cacheType, string engineName)
+            static void AddCachedStringName(TypeInfo cacheType, string engineName, string? suffix = null)
             {
                 string name = NamingUtils.SnakeToPascalCase(engineName);
+                if (!string.IsNullOrEmpty(suffix))
+                {
+                    name = $"{name}{suffix}";
+                }
 
                 var nameField = new FieldInfo($"_{engineName}_Value", KnownTypes.GodotStringName)
                 {
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/GlobalConstantsBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/GlobalConstantsBindingsDataCollector.cs
@@ -7,6 +7,12 @@ internal sealed class GlobalConstantsBindingsDataCollector : BindingsDataCollect
 {
     public override void Populate(BindingsData.CollectionContext context)
     {
+        if (context.IsExtension)
+        {
+            // Global constants are only generated for the core API, not for GDExtensions.
+            return;
+        }
+
         var globals = new TypeInfo("GlobalConstants", context.Options.Namespace)
         {
             VisibilityAttributes = VisibilityAttributes.Assembly,
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/NativeStructuresBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/NativeStructuresBindingsDataCollector.cs
@@ -13,17 +13,20 @@ internal sealed class NativeStructuresBindingsDataCollector : BindingsDataCollec
 
     public override void Initialize(BindingsData.CollectionContext context)
     {
-        // Native structures format use C/C++ type names.
-        context.TypeDB.RegisterTypeName("uint8_t", KnownTypes.SystemByte);
-        context.TypeDB.RegisterTypeName("uint16_t", KnownTypes.SystemUInt16);
-        context.TypeDB.RegisterTypeName("uint32_t", KnownTypes.SystemUInt32);
-        context.TypeDB.RegisterTypeName("uint64_t", KnownTypes.SystemUInt64);
-        context.TypeDB.RegisterTypeName("int8_t", KnownTypes.SystemSByte);
-        context.TypeDB.RegisterTypeName("int16_t", KnownTypes.SystemInt16);
-        context.TypeDB.RegisterTypeName("int32_t", KnownTypes.SystemInt32);
-        context.TypeDB.RegisterTypeName("int64_t", KnownTypes.SystemInt64);
-        context.TypeDB.RegisterTypeName("real_t", context.Options.FloatPrecision == GodotFloatTypePrecision.Double ? KnownTypes.SystemDouble : KnownTypes.SystemSingle);
-        context.TypeDB.RegisterTypeName("ObjectID", KnownTypes.SystemUInt64);
+        if (!context.IsExtension)
+        {
+            // Native structures format use C/C++ type names.
+            context.TypeDB.RegisterTypeName("uint8_t", KnownTypes.SystemByte);
+            context.TypeDB.RegisterTypeName("uint16_t", KnownTypes.SystemUInt16);
+            context.TypeDB.RegisterTypeName("uint32_t", KnownTypes.SystemUInt32);
+            context.TypeDB.RegisterTypeName("uint64_t", KnownTypes.SystemUInt64);
+            context.TypeDB.RegisterTypeName("int8_t", KnownTypes.SystemSByte);
+            context.TypeDB.RegisterTypeName("int16_t", KnownTypes.SystemInt16);
+            context.TypeDB.RegisterTypeName("int32_t", KnownTypes.SystemInt32);
+            context.TypeDB.RegisterTypeName("int64_t", KnownTypes.SystemInt64);
+            context.TypeDB.RegisterTypeName("real_t", context.Options.FloatPrecision == GodotFloatTypePrecision.Double ? KnownTypes.SystemDouble : KnownTypes.SystemSingle);
+            context.TypeDB.RegisterTypeName("ObjectID", KnownTypes.SystemUInt64);
+        }
 
         foreach (var nativeStructure in context.Api.NativeStructures)
         {
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/UtilityFunctionsBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/UtilityFunctionsBindingsDataCollector.cs
@@ -7,6 +7,12 @@ internal sealed class UtilityFunctionsBindingsDataCollector : BindingsDataCollec
 {
     public override void Populate(BindingsData.CollectionContext context)
     {
+        if (context.IsExtension)
+        {
+            // Utility functions are only generated for the core API, not for GDExtensions.
+            return;
+        }
+
         var utilityFunctionsType = new TypeInfo("UtilityFunctions", context.Options.Namespace)
         {
             VisibilityAttributes = VisibilityAttributes.Assembly,
diff --git a/src/Godot.BindingsGeneration/BindingsDataCollectors/VariadicGenericsBindingsDataCollector.cs b/src/Godot.BindingsGeneration/BindingsDataCollectors/VariadicGenericsBindingsDataCollector.cs
@@ -9,6 +9,12 @@ internal sealed class VariadicGenericsBindingsDataCollector : BindingsDataCollec
 {
     public override void Populate(BindingsData.CollectionContext context)
     {
+        if (context.IsExtension)
+        {
+            // Variadic generics are only generated for the core API, not for GDExtensions.
+            return;
+        }
+
         // Generate GodotObject.TryCallVirtualMethod<T..> and GodotObject.CallVirtualMethod<T..>
         {
             var type = new TypeInfo("GodotObject", context.Options.Namespace)
diff --git a/src/Godot.BindingsGeneration/BindingsGenerator/BindingsData.CollectionContext.cs b/src/Godot.BindingsGeneration/BindingsGenerator/BindingsData.CollectionContext.cs
@@ -24,6 +24,11 @@ internal sealed class CollectionContext
         /// </summary>
         public GodotApi Api { get; }
 
+        /// <summary>
+        /// Indicates whether the API being generated is a GDExtension instead of the core engine API.
+        /// </summary>
+        public bool IsExtension { get; init; }
+
         /// <summary>
         /// Options that were provided to the generator to configure how the
         /// bindings should be generated.
diff --git a/src/Godot.BindingsGeneration/BindingsGenerator/BindingsData.cs b/src/Godot.BindingsGeneration/BindingsGenerator/BindingsData.cs
@@ -57,7 +57,7 @@ private BindingsData(GodotApiHeader header)
     /// <summary>
     /// Constructs a <see cref="BindingsData"/> instance and populate it with the
     /// necessary information from the given <paramref name="api"/> to generate
-    /// the C# API.
+    /// the C# bindings for the engine core API.
     /// </summary>
     /// <param name="api">API information deserialized from the JSON dump.</param>
     /// <param name="options">Options that configure the bindings generation.</param>
@@ -79,6 +79,43 @@ internal static BindingsData CreateForCore(GodotApi api, BindingsGeneratorOption
         return data;
     }
 
+    /// <summary>
+    /// Constructs a <see cref="BindingsData"/> instance and populate it with the
+    /// necessary information from the given <paramref name="coreApi"/> and
+    /// <paramref name="extensionApi"/> to generate the C# bindings for the extension API.
+    /// </summary>
+    /// <param name="coreApi">API information deserialized from the JSON dump for the engine core API.</param>
+    /// <param name="extensionApi">API information deserialized from the JSON dump for the extension.</param>
+    /// <param name="options">Options that configure the bindings generation.</param>
+    /// <param name="logger">Logger that logs information messages, warnings, and errors.</param>
+    /// <returns>A populated instance of <see cref="BindingsData"/>.</returns>
+    internal static BindingsData CreateForGDExtension(GodotApi coreApi, GodotApi extensionApi, BindingsGeneratorOptions options, ILogger? logger = null)
+    {
+        logger ??= ConsoleLogger.Instance;
+
+        // First populate the data with the core API so the extension API
+        // can reference the generated types from the core API.
+        var data = CreateForCore(coreApi, new BindingsGeneratorOptions(), NullLogger.Instance);
+
+        // Clear the generated types added for the core API, since we'll only
+        // generate the extension API types.
+        data._generatedTypes.Clear();
+        data._generatedTypesByPath.Clear();
+        data._generatedTestTypesByPath.Clear();
+
+        var context = new CollectionContext(data, extensionApi, options, logger)
+        {
+            IsExtension = true,
+        };
+
+        // First create all the TypeInfo instances, then populate them as a second step
+        // so we can retrieve references to other TypeInfo instances when populating.
+        data.InitializeTypes(context);
+        data.PopulateTypes(context);
+
+        return data;
+    }
+
     private void InitializeTypes(CollectionContext context)
     {
         foreach (var collector in _dataCollectors)
diff --git a/src/Godot.BindingsGeneration/BindingsGenerator/BindingsGenerator.cs b/src/Godot.BindingsGeneration/BindingsGenerator/BindingsGenerator.cs
@@ -40,6 +40,39 @@ public static void GenerateEngineBindings(GodotApi api, IBindingsGeneratorWriter
         GenerateCore(data, writerFactory, logger);
     }
 
+    /// <summary>
+    /// Generate bindings for a GDExtension API.
+    /// </summary>
+    /// <param name="coreApi">The core engine API to use as reference for the GDExtension API.</param>
+    /// <param name="extensionApi">The GDExtension API to generate bindings for.</param>
+    /// <param name="writerFactory">The factory to create writers for the generated bindings.</param>
+    /// <param name="options">Options for configuring the behavior of the bindings generator.</param>
+    /// <param name="logger">The logger to use for logging messages during generation.</param>
+    public static void GenerateGDExtensionBindings(GodotApi coreApi, GodotApi extensionApi, IBindingsGeneratorWriterFactory writerFactory, BindingsGeneratorOptions? options = null, ILogger? logger = null)
+    {
+        options ??= new();
+        logger ??= ConsoleLogger.Instance;
+
+        if (!ValidateOptionsForGenerationAgainstCore(coreApi, options, logger))
+        {
+            return;
+        }
+
+        if (!ValidateOptionsForGeneration(extensionApi, options, logger))
+        {
+            return;
+        }
+
+        if (options.Namespace == "Godot")
+        {
+            logger.LogError("GDExtension bindings must not use the 'Godot' namespace.");
+            return;
+        }
+
+        var data = BindingsData.CreateForGDExtension(coreApi, extensionApi, options, logger);
+        GenerateCore(data, writerFactory, logger);
+    }
+
     private static bool ValidateOptionsForGeneration(GodotApi api, BindingsGeneratorOptions options, ILogger logger)
     {
         // Validate that the requested precision matches the API.
@@ -54,6 +87,20 @@ private static bool ValidateOptionsForGeneration(GodotApi api, BindingsGenerator
         return true;
     }
 
+    private static bool ValidateOptionsForGenerationAgainstCore(GodotApi coreApi, BindingsGeneratorOptions options, ILogger logger)
+    {
+        // Validate that the requested precision matches the core API that is built into the generator.
+        var apiPrecision = coreApi.Header.Precision;
+        var optionsPrecision = (GodotFloatTypePrecision)options.FloatPrecision;
+        if (apiPrecision != optionsPrecision)
+        {
+            logger.LogError($"Cannot generate GDExtension bindings for precision '{optionsPrecision}' using 'extension_api.json' which was generated by Godot built with precision '{apiPrecision}'.");
+            return false;
+        }
+
+        return true;
+    }
+
     private static void GenerateCore(BindingsData data, IBindingsGeneratorWriterFactory writerFactory, ILogger logger)
     {
         foreach (var generationData in data.Types)
diff --git a/src/Godot.Tasks/GenerateGDExtensionBindingsTask.cs b/src/Godot.Tasks/GenerateGDExtensionBindingsTask.cs
diff --git a/src/Godot.Tasks/Godot.Tasks.csproj b/src/Godot.Tasks/Godot.Tasks.csproj
diff --git a/src/Godot.Tasks/Logging/MSBuildTaskLogger.cs b/src/Godot.Tasks/Logging/MSBuildTaskLogger.cs
diff --git a/src/Godot.Tasks/PrepareGDExtensionsTask.cs b/src/Godot.Tasks/PrepareGDExtensionsTask.cs
diff --git a/src/Godot.Tasks/build/Godot.Tasks.props b/src/Godot.Tasks/build/Godot.Tasks.props
diff --git a/src/Godot.Tasks/build/Godot.Tasks.targets b/src/Godot.Tasks/build/Godot.Tasks.targets

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ private unsafe GodotObject(GodotObjectCreationOptions options)`
`107`	`107`	`GodotBridge.GDExtensionInterface.object_set_instance((void)NativePtr, &extensionClassName, (void)gcHandlePtr);`
`108`	`108`	`}`
`109`	`109`
`110`		`- if (!options.InstanceBindingAlreadyBound)`
	`110`	`+ if (!options.InstanceBindingAlreadyBound && !IsGDExtensionDefinedType())`
`111`	`111`	`{`
`112`	`112`	`var bindingCallbacks = GDExtensionInstanceBindingCallbacks.Default;`
`113`	`113`	`if (!IsUserDefinedType())`
`@@ -148,6 +148,13 @@ bool IsUserDefinedType()`
`148`	`148`	`// If this type is not defined in this assembly, it must be a user-defined type.`
`149`	`149`	`return GetType().Assembly != typeof(GodotObject).Assembly;`
`150`	`150`	`}`
	`151`	`+`
	`152`	`+ bool IsGDExtensionDefinedType()`
	`153`	`+ {`
	`154`	`+ // If this type is defined in the GDExtensionBindings assembly,`
	`155`	`+ // it must be a type defined by a GDExtension that we generated bindings for.`
	`156`	`+ return GetType().Assembly.GetName().Name == "GDExtensionBindings";`
	`157`	`+ }`
`151`	`158`	`}`
`152`	`159`
`153`	`160`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,12 @@ internal sealed class BuiltInClassesBindingsDataCollector : BindingsDataCollecto`
`18`	`18`
`19`	`19`	`public override void Initialize(BindingsData.CollectionContext context)`
`20`	`20`	`{`
	`21`	`+ if (context.IsExtension)`
	`22`	`+ {`
	`23`	`+ // Built-in classes are only generated for the core API, not for GDExtensions.`
	`24`	`+ return;`
	`25`	`+ }`
	`26`	`+`
`21`	`27`	`foreach (var engineClass in context.Api.BuiltInClasses)`
`22`	`28`	`{`
`23`	`29`	`if (!ShouldGenerateBuiltInClass(engineClass.Name) && !ShouldGenerateBuiltInClassHelpers(engineClass.Name))`
`@@ -62,6 +68,12 @@ void RegisterBuiltInType(string engineTypeName, TypeInfo type)`
`62`	`68`
`63`	`69`	`public override void Populate(BindingsData.CollectionContext context)`
`64`	`70`	`{`
	`71`	`+ if (context.IsExtension)`
	`72`	`+ {`
	`73`	`+ // Built-in classes are only generated for the core API, not for GDExtensions.`
	`74`	`+ return;`
	`75`	`+ }`
	`76`	`+`
`65`	`77`	`foreach (var engineClass in context.Api.BuiltInClasses)`
`66`	`78`	`{`
`67`	`79`	`if (!_builtinClasses.TryGetValue(engineClass.Name, out var type))`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,12 @@ internal sealed class GlobalConstantsBindingsDataCollector : BindingsDataCollect`
`7`	`7`	`{`
`8`	`8`	`public override void Populate(BindingsData.CollectionContext context)`
`9`	`9`	`{`
	`10`	`+ if (context.IsExtension)`
	`11`	`+ {`
	`12`	`+ // Global constants are only generated for the core API, not for GDExtensions.`
	`13`	`+ return;`
	`14`	`+ }`
	`15`	`+`
`10`	`16`	`var globals = new TypeInfo("GlobalConstants", context.Options.Namespace)`
`11`	`17`	`{`
`12`	`18`	`VisibilityAttributes = VisibilityAttributes.Assembly,`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,12 @@ internal sealed class VariadicGenericsBindingsDataCollector : BindingsDataCollec`
`9`	`9`	`{`
`10`	`10`	`public override void Populate(BindingsData.CollectionContext context)`
`11`	`11`	`{`
	`12`	`+ if (context.IsExtension)`
	`13`	`+ {`
	`14`	`+ // Variadic generics are only generated for the core API, not for GDExtensions.`
	`15`	`+ return;`
	`16`	`+ }`
	`17`	`+`
`12`	`18`	`// Generate GodotObject.TryCallVirtualMethod<T..> and GodotObject.CallVirtualMethod<T..>`
`13`	`19`	`{`
`14`	`20`	`var type = new TypeInfo("GodotObject", context.Options.Namespace)`