refactor(static inlined): integration test

Issue: rust-langGH-1090

Author: amanjeev

bindgen-integration/build.rs

@@ -4,7 +4,7 @@ extern crate cc;
 use bindgen::callbacks::{
     DeriveInfo, IntKind, MacroParsingBehavior, ParseCallbacks,
 };
-use bindgen::{Builder, EnumVariation};
+use bindgen::{Builder, CargoCallbacks, EnumVariation};
 use std::collections::HashSet;
 use std::env;
 use std::path::PathBuf;
@@ -207,40 +207,59 @@ fn setup_macro_test() {
 
 fn setup_extern_test() {
     // GH-1090: https://github.com/rust-lang/rust-bindgen/issues/1090
-    cc::Build::new()
-        .cpp(true)
-        .file("cpp/extern.c")
-        .include("include")
-        .compile("libextern.a");
+    // set output directory under /target so it is easy to clean generated files
     let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
     let out_rust_file = out_path.join("extern.rs");
-    let out_rust_file_relative = out_rust_file
-        .strip_prefix(std::env::current_dir().unwrap().parent().unwrap())
-        .unwrap();
-    let out_dep_file = out_path.join("extern.d");
 
-    let bindings = Builder::default()
-        .rustfmt_bindings(false)
-        .header("cpp/extern.h")
-        .clang_args(&["-x", "c++", "-I", "include"])
-        .depfile(out_rust_file_relative.display().to_string(), &out_dep_file)
+    let input_header_dir = PathBuf::from("include/").canonicalize()
+        .expect("Cannot canonicalize libdir path");
+    let input_header_file_path = input_header_dir.join("extern_stub.h");
+    let input_header_file_path_str = input_header_file_path.to_str()
+        .expect("Path could not be converted to a str");
+
+    // generate external bindings with the external .c and .h files
+    let bindings = bindgen::Builder::default()
+        .header(input_header_file_path_str)
+        .parse_callbacks(Box::new(CargoCallbacks))
         .generate_extern_functions(true)
+        .extern_functions_directory(out_path.display().to_string())
         .generate()
-        .expect("Unable to generate extern bindings");
+        .expect("Unable to generate bindings");
 
-    bindings
-        .write_to_file(&out_rust_file)
-        .expect("Couldn't write bindings!");
-    let observed_deps =
-        std::fs::read_to_string(out_dep_file).expect("Couldn't read depfile!");
-    let expected_deps = format!(
-        "{}: /tmp/bindgen/extern.hpp cpp/extern.h include/extern_stub.h",
-        out_rust_file_relative.display()
-    );
-    assert_eq!(
-        observed_deps, expected_deps,
-        "including stub via include dir must produce correct dep path",
-    );
+    println!("cargo:rustc-link-lib=extern");  // tell cargo to link libextern
+    println!("bindings generated: {}", bindings);
+
+    let obj_path = out_path.join("extern.o");
+    let lib_path = out_path.join("libextern.a");
+
+    // build the external files to check if they work
+    if !std::process::Command::new("clang")
+        .arg("-c")
+        .arg("-o")
+        .arg(&obj_path)
+        .arg(out_path.join("extern.c"))
+        .arg("-include")
+        .arg(input_header_file_path)
+        .output()
+        .expect("`clang` command error")
+        .status
+        .success() {
+        panic!("Could not compile object file");
+    }
+
+    if !std::process::Command::new("ar")
+        .arg("rcs")
+        .arg(lib_path)
+        .arg(obj_path)
+        .output()
+        .expect("`ar` command error")
+        .status
+        .success() {
+        panic!("Could not emit library file");
+    }
+
+    bindings.write_to_file(out_rust_file)
+        .expect("Cound not write bindings to the Rust file");
 }
 
 fn main() {