Reuse artifacts; apply Git patch; change C Tag* types to __Gdext* (private)

Rename opaque pointer types to highlight their private nature.
Needs an update in packed_array.rs because it accidentally uses private implementation details.

Author: Bromeon

godot-codegen/src/api_parser.rs

@@ -227,9 +227,10 @@ pub fn load_extension_api(watch: &mut godot_input::StopWatch) -> (ExtensionApi,
 
     // Use type inference, so we can accept both String (dynamically resolved) and &str (prebuilt).
     let json = godot_input::load_gdextension_json(watch);
+    let json_str: &str = json.as_ref();
 
     let model: ExtensionApi =
-        DeJson::deserialize_json(json.as_str()).expect("failed to deserialize JSON");
+        DeJson::deserialize_json(json_str).expect("failed to deserialize JSON");
     watch.record("deserialize_json");
 
     (model, build_config)

godot-core/src/builtin/packed_array.rs

@@ -9,7 +9,10 @@ use godot_ffi as sys;
 use crate::builtin::*;
 use std::fmt;
 use sys::types::*;
-use sys::{ffi_methods, interface_fn, GodotFfi, TagString, TagType};
+use sys::{ffi_methods, interface_fn, GodotFfi};
+
+// FIXME remove dependency on these types
+use sys::{__GdextString, __GdextType};
 
 /// Defines and implements a single packed array type. This macro is not hygienic and is meant to
 /// be used only in the current module.
@@ -496,7 +499,7 @@ impl_packed_array!(
     opaque_type: OpaquePackedStringArray,
     inner_type: InnerPackedStringArray,
     argument_type: GodotString,
-    return_type: TagString,
+    return_type: __GdextString,
     from_array: packed_string_array_from_array,
     operator_index: packed_string_array_operator_index,
     operator_index_const: packed_string_array_operator_index_const,
@@ -514,7 +517,7 @@ impl_packed_array!(
     opaque_type: OpaquePackedVector2Array,
     inner_type: InnerPackedVector2Array,
     argument_type: Vector2,
-    return_type: TagType,
+    return_type: __GdextType,
     from_array: packed_vector2_array_from_array,
     operator_index: packed_vector2_array_operator_index,
     operator_index_const: packed_vector2_array_operator_index_const,
@@ -532,7 +535,7 @@ impl_packed_array!(
     opaque_type: OpaquePackedVector3Array,
     inner_type: InnerPackedVector3Array,
     argument_type: Vector3,
-    return_type: TagType,
+    return_type: __GdextType,
     from_array: packed_vector3_array_from_array,
     operator_index: packed_vector3_array_operator_index,
     operator_index_const: packed_vector3_array_operator_index_const,
@@ -550,7 +553,7 @@ impl_packed_array!(
     opaque_type: OpaquePackedColorArray,
     inner_type: InnerPackedColorArray,
     argument_type: Color,
-    return_type: TagType,
+    return_type: __GdextType,
     from_array: packed_color_array_from_array,
     operator_index: packed_color_array_operator_index,
     operator_index_const: packed_color_array_operator_index_const,

godot-ffi/Cargo.toml

@@ -8,13 +8,13 @@ keywords = ["gamedev", "godot", "engine", "ffi"]
 categories = ["game-engines", "graphics"]
 
 [features]
-custom-godot = ["dep:godot-input"]
+custom-godot = ["godot-input/custom-godot"]
 codegen-fmt = ["godot-codegen/codegen-fmt"]
 #codegen-full = ["godot-codegen/codegen-full"]
 
 [dependencies]
 paste = "1"
 
 [build-dependencies]
-godot-input = { optional = true, path = "../godot-input" }
+godot-input = { path = "../godot-input" }
 godot-codegen = { path = "../godot-codegen" }

godot-ffi/build.rs

@@ -17,7 +17,7 @@ fn main() {
     std::fs::create_dir_all(gen_path).unwrap_or_else(|e| panic!("failed to create dir: {e}"));
 
     let rust_header_path = gen_path.join("gdextension_interface.rs");
-    let header = godot_input::load_gdextension_rust_header(&rust_header_path, &mut watch);
+    let header = godot_input::load_gdextension_header_rs(&rust_header_path, &mut watch);
     std::fs::write(rust_header_path, header).expect("failed to write extension header");
 
     godot_codegen::generate_sys_files(gen_path, &mut watch);

godot-ffi/src/lib.rs

@@ -32,6 +32,12 @@ pub use crate::godot_ffi::{GodotFfi, GodotFuncMarshal};
 pub use gen::central::*;
 pub use gen::gdextension_interface::*;
 
+// The impls only compile if those are different types -- ensures type safety through patch
+trait Distinct {}
+impl Distinct for GDExtensionVariantPtr {}
+impl Distinct for GDExtensionTypePtr {}
+impl Distinct for GDExtensionConstTypePtr {}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 struct GodotBinding {

godot-input/res/tweak.patch

@@ -1,8 +1,8 @@
-diff --git b/godot-codegen/input/gdextension_interface.h a/godot-codegen/input/gdextension_interface.h
+diff --git b/godot-input/gen/gdextension_interface.h a/godot-input/gen/gdextension_interface.h
 index 0b7615f..6db266e 100644
---- b/godot-codegen/input/gdextension_interface.h
-+++ a/godot-codegen/input/gdextension_interface.h
-@@ -140,22 +140,22 @@ typedef enum {
+--- b/godot-input/gen/gdextension_interface.h
++++ a/godot-input/gen/gdextension_interface.h
+@@ -139,22 +139,22 @@ typedef enum {
 
  } GDExtensionVariantOperator;
 
@@ -17,24 +17,24 @@ index 0b7615f..6db266e 100644
 -typedef void *GDExtensionTypePtr;
 -typedef const void *GDExtensionConstTypePtr;
 -typedef const void *GDExtensionMethodBindPtr;
-+typedef struct TagVariant *GDExtensionVariantPtr;
-+typedef const struct TagVariant *GDExtensionConstVariantPtr;
-+typedef struct TagStringName *GDExtensionStringNamePtr;
-+typedef const struct TagStringName *GDExtensionConstStringNamePtr;
-+typedef struct TagString *GDExtensionStringPtr;
-+typedef const struct TagString *GDExtensionConstStringPtr;
-+typedef struct TagObject *GDExtensionObjectPtr;
-+typedef const struct TagObject *GDExtensionConstObjectPtr;
-+typedef struct TagType *GDExtensionTypePtr;
-+typedef const struct TagType *GDExtensionConstTypePtr;
-+typedef struct TagMethodBind *GDExtensionMethodBindPtr;
++typedef struct __GdextVariant *GDExtensionVariantPtr;
++typedef const struct __GdextVariant *GDExtensionConstVariantPtr;
++typedef struct __GdextStringName *GDExtensionStringNamePtr;
++typedef const struct __GdextStringName *GDExtensionConstStringNamePtr;
++typedef struct __GdextString *GDExtensionStringPtr;
++typedef const struct __GdextString *GDExtensionConstStringPtr;
++typedef struct __GdextObject *GDExtensionObjectPtr;
++typedef const struct __GdextObject *GDExtensionConstObjectPtr;
++typedef struct __GdextType *GDExtensionTypePtr;
++typedef const struct __GdextType *GDExtensionConstTypePtr;
++typedef struct __GdextMethodBind *GDExtensionMethodBindPtr;
  typedef int64_t GDExtensionInt;
  typedef uint8_t GDExtensionBool;
  typedef uint64_t GDObjectInstanceID;
 -typedef void *GDExtensionRefPtr;
 -typedef const void *GDExtensionConstRefPtr;
-+typedef struct TagExtensionRef *GDExtensionRefPtr;
-+typedef const struct TagExtensionRef *GDExtensionConstRefPtr;
++typedef struct __GdextExtensionRef *GDExtensionRefPtr;
++typedef const struct __GdextExtensionRef *GDExtensionConstRefPtr;
 
  /* VARIANT DATA I/O */
 

godot-input/src/godot_exe.rs

@@ -5,7 +5,7 @@
  */
 
 use crate::godot_version::parse_godot_version;
-use crate::header_gen::run_bindgen;
+use crate::header_gen::generate_rust_binding;
 use crate::watch::StopWatch;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -15,6 +15,7 @@ use std::process::Command;
 const GODOT_VERSION_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/godot_version.txt");
 const JSON_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/extension_api.json");
 const HEADER_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/gen/gdextension_interface.h");
+const RES_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/res");
 
 pub fn load_gdextension_json(watch: &mut StopWatch) -> String {
     let json_path = Path::new(JSON_PATH);
@@ -26,12 +27,12 @@ pub fn load_gdextension_json(watch: &mut StopWatch) -> String {
 
     // Regenerate API JSON if first time or Godot version is different
     let version = read_godot_version(&godot_bin);
-    if !json_path.exists() || has_version_changed(&version) {
-        dump_extension_api(&godot_bin, json_path);
-        update_version_file(&version);
+    // if !json_path.exists() || has_version_changed(&version) {
+    dump_extension_api(&godot_bin, json_path);
+    update_version_file(&version);
 
-        watch.record("dump_gdextension_json");
-    }
+    watch.record("dump_gdextension_json");
+    // }
 
     let result = std::fs::read_to_string(json_path)
         .unwrap_or_else(|_| panic!("failed to open file {}", json_path.display()));
@@ -40,8 +41,9 @@ pub fn load_gdextension_json(watch: &mut StopWatch) -> String {
     result
 }
 
-pub fn load_gdextension_rust_header(rust_out_path: &Path, watch: &mut StopWatch) -> String {
+pub fn load_gdextension_header_rs(rust_out_path: &Path, watch: &mut StopWatch) -> String {
     let c_header_path = Path::new(HEADER_PATH);
+    let resource_path = Path::new(RES_PATH);
     rerun_on_changed(c_header_path);
 
     let godot_bin = locate_godot_binary();
@@ -50,14 +52,16 @@ pub fn load_gdextension_rust_header(rust_out_path: &Path, watch: &mut StopWatch)
 
     // Regenerate API JSON if first time or Godot version is different
     let version = read_godot_version(&godot_bin);
-    if !c_header_path.exists() || has_version_changed(&version) {
-        dump_header_file(&godot_bin, c_header_path);
-        update_version_file(&version);
+    // if !c_header_path.exists() || has_version_changed(&version) {
+    dump_header_file(&godot_bin, c_header_path);
+    update_version_file(&version);
 
-        watch.record("dump_gdextension_header");
-    }
+    watch.record("dump_gdextension_header");
+    // }
+
+    patch_c_header(&resource_path.join("tweak.patch"));
+    generate_rust_binding(c_header_path, rust_out_path);
 
-    run_bindgen(c_header_path, rust_out_path);
     watch.record("read_header_file");
     std::fs::read_to_string(rust_out_path).unwrap_or_else(|_| {
         panic!(
@@ -67,6 +71,7 @@ pub fn load_gdextension_rust_header(rust_out_path: &Path, watch: &mut StopWatch)
     })
 }
 
+#[allow(dead_code)]
 fn has_version_changed(current_version: &str) -> bool {
     let version_path = Path::new(GODOT_VERSION_PATH);
 
@@ -121,18 +126,12 @@ fn dump_extension_api(godot_bin: &Path, out_file: &Path) {
     std::fs::create_dir_all(cwd).unwrap_or_else(|_| panic!("create directory '{}'", cwd.display()));
     println!("Dump GDExtension API JSON to dir '{}'...", cwd.display());
 
-    Command::new(godot_bin)
-        .current_dir(cwd)
+    let mut cmd = Command::new(godot_bin);
+    cmd.current_dir(cwd)
         .arg("--headless")
-        .arg("--dump-extension-api")
-        .arg(cwd)
-        .output()
-        .unwrap_or_else(|_| {
-            panic!(
-                "failed to invoke Godot executable '{}'",
-                godot_bin.display()
-            )
-        });
+        .arg("--dump-extension-api");
+
+    execute(cmd, "dump Godot header file");
 
     println!("Generated {}/gdextension_interface.h.", cwd.display());
 }
@@ -142,22 +141,28 @@ fn dump_header_file(godot_bin: &Path, out_file: &Path) {
     std::fs::create_dir_all(cwd).unwrap_or_else(|_| panic!("create directory '{}'", cwd.display()));
     println!("Dump GDExtension header file to dir '{}'...", cwd.display());
 
-    Command::new(godot_bin)
-        .current_dir(cwd)
+    let mut cmd = Command::new(godot_bin);
+    cmd.current_dir(cwd)
         .arg("--headless")
-        .arg("--dump-gdextension-interface")
-        .arg(cwd)
-        .output()
-        .unwrap_or_else(|_| {
-            panic!(
-                "failed to invoke Godot executable '{}'",
-                godot_bin.display()
-            )
-        });
+        .arg("--dump-gdextension-interface");
+
+    execute(cmd, "dump Godot JSON file");
 
     println!("Generated {}/extension_api.json.", cwd.display());
 }
 
+fn patch_c_header(tweak_path: &Path) {
+    // Note: patch must have paths relative to Git root (aka top-level dir), so cwd is root
+    let cwd = tweak_path.parent().unwrap().parent().unwrap();
+    rerun_on_changed(tweak_path);
+
+    let git = locate_git_binary();
+    let mut cmd = Command::new(&git);
+    cmd.current_dir(cwd).arg("apply").arg("-v").arg(tweak_path);
+
+    execute(cmd, "apply Git patch");
+}
+
 fn locate_godot_binary() -> PathBuf {
     if let Ok(string) = std::env::var("GODOT4_BIN") {
         println!("Found GODOT4_BIN with path to executable: '{string}'");
@@ -167,12 +172,40 @@ fn locate_godot_binary() -> PathBuf {
         path
     } else {
         panic!(
-            "Bindings generation requires 'godot4' executable or a GODOT4_BIN \
+            "gdext with `custom-godot` feature requires 'godot4' executable or a GODOT4_BIN \
+                 environment variable (with the path to the executable)."
+        )
+    }
+}
+
+fn locate_git_binary() -> PathBuf {
+    if let Ok(string) = std::env::var("GIT_BIN") {
+        println!("Found GIT_BIN with path to executable: '{string}'");
+        PathBuf::from(string)
+    } else if let Ok(path) = which::which("git") {
+        println!("Found 'git' executable in PATH: {}", path.display());
+        path
+    } else {
+        panic!(
+            "gdext with `custom-godot` feature requires `git` executable or a GIT_BIN \
                  environment variable (with the path to the executable)."
         )
     }
 }
 
+fn execute(mut cmd: Command, error_message: &str) {
+    let output = cmd
+        .output()
+        .unwrap_or_else(|_| panic!("failed to execute command: {error_message}"));
+
+    if !output.status.success() {
+        println!("[stdout] {}", String::from_utf8(output.stdout).unwrap());
+        println!("[stderr] {}", String::from_utf8(output.stderr).unwrap());
+        println!("[status] {}", output.status);
+        panic!("command returned error: {error_message}");
+    }
+}
+
 fn rerun_on_changed(path: &Path) {
     println!("cargo:rerun-if-changed={}", path.display());
     println!("cargo:rerun-if-env-changed=GODOT4_BIN");

godot-input/src/header_gen.rs

@@ -7,7 +7,7 @@
 use std::env;
 use std::path::Path;
 
-pub(crate) fn run_bindgen(c_header_path: &Path, out_rust_path: &Path) {
+pub(crate) fn generate_rust_binding(c_header_path: &Path, out_rust_path: &Path) {
     let c_header_path = c_header_path.display().to_string();
     println!("cargo:rerun-if-changed={}", c_header_path);