Patch gdextension_interface.h with Rust regex instead of git patch

Author: Bromeon

godot-bindings/src/godot_exe.rs

@@ -9,6 +9,9 @@
 use crate::godot_version::parse_godot_version;
 use crate::header_gen::generate_rust_binding;
 use crate::watch::StopWatch;
+
+use regex::Regex;
+use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
 
@@ -26,7 +29,6 @@ const HEADER_PATH: &str = concat!(
     env!("CARGO_MANIFEST_DIR"),
     "/../target/godot-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);
@@ -45,7 +47,7 @@ pub fn load_gdextension_json(watch: &mut StopWatch) -> String {
     watch.record("dump_json");
     // }
 
-    let result = std::fs::read_to_string(json_path)
+    let result = fs::read_to_string(json_path)
         .unwrap_or_else(|_| panic!("failed to open file {}", json_path.display()));
 
     watch.record("read_json_file");
@@ -81,8 +83,7 @@ pub fn load_gdextension_header_rs(
 
     watch.record("dump_header_c");
 
-    let tweak_path = Path::new(RES_PATH).join("tweak.patch");
-    patch_c_header(c_header_path, &tweak_path);
+    patch_c_header(c_header_path);
     generate_rust_binding(c_header_path, rust_out_path);
 
     watch.record("generate_header_rs");
@@ -92,7 +93,7 @@ pub fn load_gdextension_header_rs(
 fn has_version_changed(current_version: &str) -> bool {
     let version_path = Path::new(GODOT_VERSION_PATH);
 
-    match std::fs::read_to_string(version_path) {
+    match fs::read_to_string(version_path) {
         Ok(last_version) => current_version != last_version,
         Err(_) => true,
     }
@@ -168,26 +169,30 @@ fn dump_header_file(godot_bin: &Path, out_file: &Path) {
     println!("Generated {}/extension_api.json.", cwd.display());
 }
 
-fn patch_c_header(c_header_path: &Path, tweak_path: &Path) {
+fn patch_c_header(c_header_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`.
-    let cwd = c_header_path.parent().unwrap().parent().unwrap();
-    println!("cwd: {}", cwd.display());
 
-    // Note: patch must have paths relative to Git root (aka top-level dir), so cwd is root
-    rerun_on_changed(tweak_path);
+    // Read the contents of the file into a string
+    let c = fs::read_to_string(c_header_path)
+        .unwrap_or_else(|_| panic!("failed to read C header file {}", c_header_path.display()));
 
-    let git = locate_git_binary();
-    let mut cmd = Command::new(&git);
-    cmd.current_dir(cwd).arg("apply").arg("-v").arg(tweak_path);
+    // 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;");
 
-    let output = execute(cmd, "apply Git patch");
-    let stderr = String::from_utf8(output.stderr).expect("convert Git patch output to UTF-8");
+    println!("Patched contents:\n\n{}\n\n", c.as_ref());
 
-    // `git patch` returns 0 even if it skips a patch because it's not applicable -- treat this as error
-    assert!(!stderr.contains("Skipped"), "Git patch was skipped");
+    // Write the modified contents back to the file
+    fs::write(c_header_path, c.as_ref()).unwrap_or_else(|_| {
+        panic!(
+            "failed to write patched C header file {}",
+            c_header_path.display()
+        )
+    });
 }
-
 fn locate_godot_binary() -> PathBuf {
     if let Ok(string) = std::env::var("GODOT4_BIN") {
         println!("Found GODOT4_BIN with path to executable: '{string}'");
@@ -204,21 +209,6 @@ fn locate_godot_binary() -> PathBuf {
     }
 }
 
-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) -> Output {
     let output = cmd
         .output()

godot-bindings/src/lib.rs

@@ -10,14 +10,18 @@ use std::path::Path;
 
 pub use watch::StopWatch;
 
-// Features `custom-godot` and `godot4-artifacts` are mutually exclusive.
+#[cfg(all(feature = "custom-godot", feature = "prebuilt-godot"))]
+compile_error!("Exactly one of `custom-godot` or `prebuilt-godot` must be specified (both given).");
+
+#[cfg(not(any(feature = "custom-godot", feature = "prebuilt-godot")))]
+compile_error!("Exactly one of `custom-godot` or `prebuilt-godot` must be specified (none given).");
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Regenerate all files
 
 #[cfg(feature = "custom-godot")]
 #[path = ""]
-mod rebuilt {
+mod custom {
     use super::*;
 
     pub(crate) mod godot_exe;
@@ -41,30 +45,30 @@ mod rebuilt {
 }
 
 #[cfg(feature = "custom-godot")]
-pub use rebuilt::*;
+pub use custom::*;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Reuse existing files
 
-#[cfg(not(feature = "custom-godot"))]
+#[cfg(feature = "prebuilt-godot")]
 #[path = ""]
-mod existing {
+mod prebuilt {
     use super::*;
 
     pub fn load_gdextension_json(_watch: &mut StopWatch) -> &'static str {
-        godot4_artifacts::load_gdextension_json()
+        godot4_prebuilt::load_gdextension_json()
     }
 
     pub fn write_gdextension_header_rs(to: &Path, _watch: &mut StopWatch) {
         // Note: prebuilt artifacts just return a static str.
-        let header_rs = godot4_artifacts::load_gdextension_header_rs();
+        let header_rs = godot4_prebuilt::load_gdextension_header_rs();
         std::fs::write(to, header_rs)
             .unwrap_or_else(|e| panic!("failed to write gdextension_interface.rs: {e}"));
     }
 }
 
-#[cfg(not(feature = "custom-godot"))]
-pub use existing::*;
+#[cfg(feature = "prebuilt-godot")]
+pub use prebuilt::*;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Common

godot-codegen/src/api_parser.rs

@@ -226,7 +226,10 @@ pub fn load_extension_api(watch: &mut godot_bindings::StopWatch) -> (ExtensionAp
     let build_config = "float_64"; // TODO infer this
 
     // Use type inference, so we can accept both String (dynamically resolved) and &str (prebuilt).
+    // #[allow]: as_ref() acts as impl AsRef<str>, but with conditional compilation
+
     let json = godot_bindings::load_gdextension_json(watch);
+    #[allow(clippy::useless_asref)]
     let json_str: &str = json.as_ref();
 
     let model: ExtensionApi =

godot-core/src/obj/gd.rs

@@ -162,7 +162,7 @@ where
         let callbacks = crate::storage::nop_instance_callbacks();
 
         unsafe {
-            let token = sys::get_library();
+            let token = sys::get_library() as *mut std::ffi::c_void;
             let binding =
                 interface_fn!(object_get_instance_binding)(self.obj_sys(), token, &callbacks);
 
@@ -171,7 +171,7 @@ where
                 "Class {} -- null instance; does the class have a Godot creator function?",
                 std::any::type_name::<T>()
             );
-            crate::private::as_storage::<T>(binding)
+            crate::private::as_storage::<T>(binding as sys::GDExtensionClassInstancePtr)
         }
     }
 }

godot-core/src/registry.rs

@@ -299,15 +299,15 @@ pub mod callbacks {
         let user_instance = make_user_instance(base);
         let instance = InstanceStorage::<T>::construct(user_instance);
         let instance_ptr = instance.into_raw();
-        let instance_ptr = instance_ptr as *mut std::ffi::c_void; // TODO GDExtensionClassInstancePtr
+        let instance_ptr = instance_ptr as sys::GDExtensionClassInstancePtr;
 
         let binding_data_callbacks = crate::storage::nop_instance_callbacks();
         unsafe {
             interface_fn!(object_set_instance)(base_ptr, class_name.string_sys(), instance_ptr);
             interface_fn!(object_set_instance_binding)(
                 base_ptr,
-                sys::get_library(),
-                instance_ptr,
+                sys::get_library() as *mut std::ffi::c_void,
+                instance_ptr as *mut std::ffi::c_void,
                 &binding_data_callbacks,
             );
         }