Allow users to generate API from user-provided JSON

- Remove `GODOT4_GDEXTENSION_HEADERS` – it can be introduced as separate feature (after someone presents solid usecase for that).

Author: Yarwin

.github/composite/godot-itest/action.yml

@@ -94,6 +94,7 @@ runs:
         with-llvm: ${{ inputs.with-llvm }}
         cache-key: ${{ inputs.rust-cache-key }}
 
+    # if
     - name: "Patch prebuilt version ({{ inputs.godot-prebuilt-patch }})"
       if: inputs.godot-prebuilt-patch != ''
       env:
@@ -132,7 +133,7 @@ runs:
 
     # else if
     - name: "Dump extension api"
-      if: inputs.godot-indirect-json == 'true' && inputs.godot-prebuilt-patch == ''
+      if: inputs.godot-prebuilt-patch == '' && inputs.godot-indirect-json == 'true'
       run: |
         $GODOT4_BIN --headless --dump-extension-api
         mv extension_api.json $RUNNER_DIR/godot_bin/extension_api.json

godot-bindings/Cargo.toml

@@ -43,7 +43,7 @@ gdextension-api = { workspace = true }
 bindgen = { workspace = true, optional = true }
 regex = { workspace = true, optional = true }
 which = { workspace = true, optional = true }
-# required by `api-custom-json` to parse the extension api header (to get the Godot version).
+# Required by `api-custom-json` to parse the extension API JSON (to get the Godot version).
 nanoserde = { workspace = true, optional = true }
 
 [dev-dependencies]

godot-bindings/src/godot_exe.rs

@@ -8,14 +8,14 @@
 //! Commands related to Godot executable
 
 use crate::godot_version::{parse_godot_version, validate_godot_version};
-use crate::header_gen::{generate_rust_binding, patch_c_header};
+use crate::header_gen::generate_rust_binding;
 use crate::watch::StopWatch;
 use crate::GodotVersion;
 
+use regex::Regex;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
-
 // Note: CARGO_BUILD_TARGET_DIR and CARGO_TARGET_DIR are not set.
 // OUT_DIR would be standing to reason, but it's an unspecified path that cannot be referenced by CI.
 // const GODOT_VERSION_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/src/gen/godot_version.txt");
@@ -111,7 +111,7 @@ pub(crate) fn read_godot_version(godot_bin: &Path) -> GodotVersion {
 
     let version = parse_godot_version(stdout)
         .unwrap_or_else(|err| panic!("failed to parse Godot version '{stdout}': {err}"));
-    validate_godot_version(&version, stdout);
+    validate_godot_version(&version);
 
     // `--dump-extension-api`, `--dump-gdextension-interface` etc. are only available in Debug builds (editor, debug export template).
     // If we try to run them in release builds, Godot tries to run, causing a popup alert with an unhelpful message:
@@ -170,6 +170,53 @@ fn dump_header_file(godot_bin: &Path, out_file: &Path) {
     println!("Generated {}/gdextension_interface.h.", cwd.display());
 }
 
+pub(crate) fn patch_c_header(in_h_path: &Path, out_h_path: &Path) {
+    // The C header path *must* be passed in by the invoking crate, as the path cannot be relative to this crate.
+    // Otherwise, it can be something like `/home/runner/.cargo/git/checkouts/gdext-76630c89719e160c/efd3b94/godot-bindings`.
+
+    println!("Patch C header '{}'...", in_h_path.display());
+
+    let mut c = fs::read_to_string(in_h_path)
+        .unwrap_or_else(|_| panic!("failed to read C header file {}", in_h_path.display()));
+
+    // Detect whether header is legacy (4.0) format. This should generally already be checked outside.
+    assert!(
+        c.contains("GDExtensionInterfaceGetProcAddress"),
+        "C header file '{}' seems to be GDExtension version 4.0, which is no longer support by godot-rust.",
+        in_h_path.display()
+    );
+
+    // Patch for variant converters and type constructors.
+    c = c.replace(
+        "typedef void (*GDExtensionVariantFromTypeConstructorFunc)(GDExtensionVariantPtr, GDExtensionTypePtr);",
+        "typedef void (*GDExtensionVariantFromTypeConstructorFunc)(GDExtensionUninitializedVariantPtr, GDExtensionTypePtr);"
+    )
+    .replace(
+        "typedef void (*GDExtensionTypeFromVariantConstructorFunc)(GDExtensionTypePtr, GDExtensionVariantPtr);",
+        "typedef void (*GDExtensionTypeFromVariantConstructorFunc)(GDExtensionUninitializedTypePtr, GDExtensionVariantPtr);"
+    )
+    .replace(
+        "typedef void (*GDExtensionPtrConstructor)(GDExtensionTypePtr p_base, const GDExtensionConstTypePtr *p_args);",
+        "typedef void (*GDExtensionPtrConstructor)(GDExtensionUninitializedTypePtr p_base, const GDExtensionConstTypePtr *p_args);"
+    );
+
+    // Use single regex with independent "const"/"Const", as there are definitions like this:
+    // typedef const void *GDExtensionMethodBindPtr;
+    let c = Regex::new(r"typedef (const )?void \*GDExtension(Const)?([a-zA-Z0-9]+?)Ptr;") //
+        .expect("regex for mut typedef")
+        .replace_all(&c, "typedef ${1}struct __Gdext$3 *GDExtension${2}${3}Ptr;");
+
+    // println!("Patched contents:\n\n{}\n\n", c.as_ref());
+
+    // Write the modified contents back to the file
+    fs::write(out_h_path, c.as_ref()).unwrap_or_else(|_| {
+        panic!(
+            "failed to write patched C header file {}",
+            out_h_path.display()
+        )
+    });
+}
+
 pub(crate) fn locate_godot_binary() -> PathBuf {
     if let Ok(string) = std::env::var("GODOT4_BIN") {
         println!("Found GODOT4_BIN with path to executable: '{string}'");

godot-bindings/src/godot_json.rs

@@ -14,7 +14,7 @@
 // Moving said types to `godot-bindings` would increase the cognitive overhead (since domain mapping is responsibility of `godot-codegen`, while godot-bindings is responsible for providing required resources & emitting the version).
 // In the future we might experiment with splitting said types into separate crates.
 
-use crate::depend_on_custom_json::header_gen::{generate_rust_binding, patch_c_header};
+use crate::depend_on_custom_json::header_gen::generate_rust_binding;
 use crate::godot_version::validate_godot_version;
 use crate::{GodotVersion, StopWatch};
 use nanoserde::DeJson;
@@ -79,7 +79,7 @@ pub(crate) fn read_godot_version() -> GodotVersion {
         .expect("failed to deserialize JSON");
     let version = extension_api.header.into_godot_version();
 
-    validate_godot_version(&version, &version.full_string);
+    validate_godot_version(&version);
 
     version
 }
@@ -89,17 +89,10 @@ pub(crate) fn write_gdextension_headers(
     out_rs_path: &Path,
     watch: &mut StopWatch,
 ) {
-    // Allow to use custom gdextension headers in unlikely case if one uses heavily modified version of the engine.
-    if let Ok(path) = std::env::var("GODOT4_GDEXTENSION_HEADERS") {
-        let in_h_path = Path::new(&path);
-        patch_c_header(in_h_path, out_h_path);
-        watch.record("patch_header_h");
-    } else {
-        let h_contents = load_latest_gdextension_headers();
-        fs::write(out_h_path, h_contents.as_ref())
-            .unwrap_or_else(|e| panic!("failed to write gdextension_interface.h: {e}"));
-        watch.record("write_header_h");
-    }
+    let h_contents = load_latest_gdextension_headers();
+    fs::write(out_h_path, h_contents.as_ref())
+        .unwrap_or_else(|e| panic!("failed to write gdextension_interface.h: {e}"));
+    watch.record("write_header_h");
 
     generate_rust_binding(out_h_path, out_rs_path);
     watch.record("generate_header_rs");

godot-bindings/src/godot_version.rs

@@ -7,7 +7,7 @@
 
 // This file is explicitly included in unit tests
 // while all the functions included are used only with `custom-api` and `custom-api-json` features.
-#![allow(unused_variables, dead_code)]
+#![cfg_attr(not(feature = "api-custom"), allow(unused_variables, dead_code))]
 
 use crate::GodotVersion;
 use regex::{Captures, Regex};
@@ -54,18 +54,17 @@ pub fn parse_godot_version(version_str: &str) -> Result<GodotVersion, Box<dyn Er
     })
 }
 
-pub(crate) fn validate_godot_version(godot_version: &GodotVersion, version_str: &str) {
+pub(crate) fn validate_godot_version(godot_version: &GodotVersion) {
     assert_eq!(
-        godot_version.major,
-        4,
+        godot_version.major, 4,
         "Only Godot versions with major version 4 are supported; found version {}.",
-        version_str.trim()
+        godot_version.full_string
     );
 
     assert!(
         godot_version.minor > 0,
         "Godot 4.0 is no longer supported by godot-rust; found version {}.",
-        version_str.trim()
+        godot_version.full_string
     );
 }
 

godot-bindings/src/header_gen.rs

@@ -5,56 +5,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use regex::Regex;
+use std::env;
 use std::path::Path;
-use std::{env, fs};
-
-pub(crate) fn patch_c_header(in_h_path: &Path, out_h_path: &Path) {
-    // The C header path *must* be passed in by the invoking crate, as the path cannot be relative to this crate.
-    // Otherwise, it can be something like `/home/runner/.cargo/git/checkouts/gdext-76630c89719e160c/efd3b94/godot-bindings`.
-
-    println!("Patch C header '{}'...", in_h_path.display());
-
-    let mut c = fs::read_to_string(in_h_path)
-        .unwrap_or_else(|_| panic!("failed to read C header file {}", in_h_path.display()));
-
-    // Detect whether header is legacy (4.0) format. This should generally already be checked outside.
-    assert!(
-        c.contains("GDExtensionInterfaceGetProcAddress"),
-        "C header file '{}' seems to be GDExtension version 4.0, which is no longer support by godot-rust.",
-        in_h_path.display()
-    );
-
-    // Patch for variant converters and type constructors.
-    c = c.replace(
-        "typedef void (*GDExtensionVariantFromTypeConstructorFunc)(GDExtensionVariantPtr, GDExtensionTypePtr);",
-        "typedef void (*GDExtensionVariantFromTypeConstructorFunc)(GDExtensionUninitializedVariantPtr, GDExtensionTypePtr);"
-    )
-        .replace(
-            "typedef void (*GDExtensionTypeFromVariantConstructorFunc)(GDExtensionTypePtr, GDExtensionVariantPtr);",
-            "typedef void (*GDExtensionTypeFromVariantConstructorFunc)(GDExtensionUninitializedTypePtr, GDExtensionVariantPtr);"
-        )
-        .replace(
-            "typedef void (*GDExtensionPtrConstructor)(GDExtensionTypePtr p_base, const GDExtensionConstTypePtr *p_args);",
-            "typedef void (*GDExtensionPtrConstructor)(GDExtensionUninitializedTypePtr p_base, const GDExtensionConstTypePtr *p_args);"
-        );
-
-    // Use single regex with independent "const"/"Const", as there are definitions like this:
-    // typedef const void *GDExtensionMethodBindPtr;
-    let c = Regex::new(r"typedef (const )?void \*GDExtension(Const)?([a-zA-Z0-9]+?)Ptr;") //
-        .expect("regex for mut typedef")
-        .replace_all(&c, "typedef ${1}struct __Gdext$3 *GDExtension${2}${3}Ptr;");
-
-    // println!("Patched contents:\n\n{}\n\n", c.as_ref());
-
-    // Write the modified contents back to the file
-    fs::write(out_h_path, c.as_ref()).unwrap_or_else(|_| {
-        panic!(
-            "failed to write patched C header file {}",
-            out_h_path.display()
-        )
-    });
-}
 
 pub(crate) fn generate_rust_binding(in_h_path: &Path, out_rs_path: &Path) {
     let c_header_path = in_h_path.display().to_string();

godot-bindings/src/lib.rs

@@ -92,7 +92,7 @@ mod depend_on_custom_json {
 
     pub fn load_gdextension_json(watch: &mut StopWatch) -> Cow<'static, str> {
         let result = godot_json::load_custom_gdextension_json();
-        watch.record("read_api_json");
+        watch.record("read_api_custom_json");
         Cow::Owned(result)
     }
 

godot/src/lib.rs

@@ -77,10 +77,8 @@
 //!
 //!   `api-custom` feature requires specifying `GODOT4_BIN` environment variable with a path to your Godot4 binary.
 //!
-//!   `api-custom-json` feature requires specifying `GODOT4_GDEXTENSION_JSON` environment variable with a path
-//!   to extension api json.
-//!   By default, `api-custom-json` will fetch the latest GDExtension headers, which are backward-compatible and will work with all the up-to-date Godot versions.
-//!   `GODOT4_GDEXTENSION_HEADERS` can be set to use custom, user-specified headers instead.<br><br>
+//!   The `api-custom-json` feature requires specifying `GODOT4_GDEXTENSION_JSON` environment variable with a path
+//!   to your custom-defined `extension_api.json`.<br><br>
 //!
 //! * **`double-precision`**
 //!