Revert all changes - see what CI is doing

Author: GKFX

.github/workflows/bindgen.yml

@@ -50,20 +50,20 @@ jobs:
         with:
           # MSRV below is documented in Cargo.toml and README.md, please update those if you
           # change this.
-          toolchain: 1.70.0
+          toolchain: 1.60.0
 
       - name: Test lib with msrv
-        run: cargo +1.70.0 test --package bindgen
+        run: cargo +1.60.0 test --package bindgen
 
       - name: Install msrv for cli
         uses: dtolnay/rust-toolchain@master
         with:
           # MSRV below is documented in Cargo.toml and README.md, please update those if you
           # change this.
-          toolchain: 1.70.0
+          toolchain: 1.64.0
 
       - name: Test cli with msrv
-        run: cargo +1.70.0 build --package bindgen-cli
+        run: cargo +1.64.0 build --package bindgen-cli
 
   minimal:
     runs-on: ubuntu-latest

Cargo.lock

@@ -39,9 +39,9 @@ extern "C" {
 
 ## MSRV
 
-The `bindgen` minimum supported Rust version is **1.70.0**.
+The `bindgen` minimum supported Rust version is **1.60.0**.
 
-The `bindgen-cli` minimum supported Rust version is **1.70.0**.
+The `bindgen-cli` minimum supported Rust version is **1.64.0**.
 
 No MSRV bump policy has been established yet, so MSRV may increase in any release.
 

README.md

@@ -13,7 +13,7 @@ documentation = "https://docs.rs/bindgen"
 homepage = "https://rust-lang.github.io/rust-bindgen/"
 version = "0.69.4"
 edition = "2018"
-rust-version = "1.70.0"
+rust-version = "1.64.0"
 
 [[bin]]
 path = "main.rs"

bindgen-cli/Cargo.toml

@@ -3,7 +3,7 @@ name = "quickchecking"
 description = "Bindgen property tests with quickcheck. Generate random valid C code and pass it to the csmith/predicate.py script"
 version = "0.0.0"
 publish = false
-rust-version = "1.70"
+rust-version = "1.64"
 edition = "2018"
 
 [lib]
@@ -16,6 +16,7 @@ path = "src/bin.rs"
 
 [dependencies]
 clap = "4"
+lazy_static = "1.0"
 quickcheck = "1.0"
 tempfile = "3"
 

bindgen-tests/tests/quickchecking/Cargo.toml

@@ -14,7 +14,10 @@
 //!     println!("{}", header);
 //! }
 //! ```
+//!
 #![deny(missing_docs)]
+#[macro_use]
+extern crate lazy_static;
 
 use quickcheck::{Gen, QuickCheck, TestResult};
 use std::error::Error;
@@ -35,7 +38,10 @@ struct Context {
 }
 
 // Initialize global context.
-static CONTEXT: Mutex<Context> = Mutex::new(Context { output_path: None });
+lazy_static! {
+    static ref CONTEXT: Mutex<Context> =
+        Mutex::new(Context { output_path: None });
+}
 
 // Passes fuzzed header to the `csmith-fuzzing/predicate.py` script, returns
 // output of the associated command.

bindgen-tests/tests/quickchecking/src/lib.rs

@@ -18,7 +18,7 @@ version = "0.69.4"
 edition = "2018"
 build = "build.rs"
 # If you change this, also update README.md and msrv in .github/workflows/bindgen.yml
-rust-version = "1.70.0"
+rust-version = "1.60.0"
 
 [lib]
 name = "bindgen"
@@ -30,6 +30,8 @@ bitflags = "2.2.1"
 cexpr = "0.6"
 clang-sys = { version = "1", features = ["clang_6_0"] }
 itertools = { version = ">=0.10,<0.13", default-features = false }
+lazy_static = "1"
+lazycell = "1"
 log = { version = "0.4", optional = true }
 prettyplease = { version = "0.2.7", optional = true, features = ["verbatim"] }
 proc-macro2 = { version = "1", default-features = false }

bindgen/Cargo.toml

@@ -7,16 +7,21 @@ pub use crate::ir::int::IntKind;
 use std::fmt;
 
 /// An enum to allow ignoring parsing of macros.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum MacroParsingBehavior {
     /// Ignore the macro, generating no code for it, or anything that depends on
     /// it.
     Ignore,
     /// The default behavior bindgen would have otherwise.
-    #[default]
     Default,
 }
 
+impl Default for MacroParsingBehavior {
+    fn default() -> Self {
+        MacroParsingBehavior::Default
+    }
+}
+
 /// A trait to allow configuring different kinds of types in different
 /// situations.
 pub trait ParseCallbacks: fmt::Debug {

bindgen/callbacks.rs

@@ -14,7 +14,6 @@ use std::fs::OpenOptions;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
-use std::sync::OnceLock;
 use std::{mem, ptr, slice};
 
 /// Type representing a clang attribute.
@@ -1529,13 +1528,13 @@ impl Type {
     pub(crate) fn is_associated_type(&self) -> bool {
         // This is terrible :(
         fn hacky_parse_associated_type<S: AsRef<str>>(spelling: S) -> bool {
-            static ASSOC_TYPE_RE: OnceLock<regex::Regex> = OnceLock::new();
-            ASSOC_TYPE_RE
-                .get_or_init(|| {
-                    regex::Regex::new(r"typename type\-parameter\-\d+\-\d+::.+")
-                        .unwrap()
-                })
-                .is_match(spelling.as_ref())
+            lazy_static! {
+                static ref ASSOC_TYPE_RE: regex::Regex = regex::Regex::new(
+                    r"typename type\-parameter\-\d+\-\d+::.+"
+                )
+                .unwrap();
+            }
+            ASSOC_TYPE_RE.is_match(spelling.as_ref())
         }
 
         self.kind() == CXType_Unexposed &&

bindgen/clang.rs

@@ -2608,7 +2608,7 @@ impl CodeGenerator for CompInfo {
                 ctx,
                 &canonical_ident,
                 flex_inner_ty,
-                &generic_param_names,
+                &*generic_param_names,
                 &impl_generics_labels,
             ));
         }
@@ -3010,7 +3010,7 @@ impl Method {
 }
 
 /// A helper type that represents different enum variations.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum EnumVariation {
     /// The code for this enum will use a Rust enum. Note that creating this in unsafe code
     /// (including FFI) with an invalid value will invoke undefined behaviour, whether or not
@@ -3027,7 +3027,6 @@ pub enum EnumVariation {
         is_global: bool,
     },
     /// The code for this enum will use consts
-    #[default]
     Consts,
     /// The code for this enum will use a module containing consts
     ModuleConsts,
@@ -3045,6 +3044,12 @@ impl EnumVariation {
     }
 }
 
+impl Default for EnumVariation {
+    fn default() -> EnumVariation {
+        EnumVariation::Consts
+    }
+}
+
 impl fmt::Display for EnumVariation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
@@ -3752,12 +3757,11 @@ impl CodeGenerator for Enum {
 }
 
 /// Enum for the default type of macro constants.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum MacroTypeVariation {
     /// Use i32 or i64
     Signed,
     /// Use u32 or u64
-    #[default]
     Unsigned,
 }
 
@@ -3771,6 +3775,12 @@ impl fmt::Display for MacroTypeVariation {
     }
 }
 
+impl Default for MacroTypeVariation {
+    fn default() -> MacroTypeVariation {
+        MacroTypeVariation::Unsigned
+    }
+}
+
 impl std::str::FromStr for MacroTypeVariation {
     type Err = std::io::Error;
 
@@ -3791,10 +3801,9 @@ impl std::str::FromStr for MacroTypeVariation {
 }
 
 /// Enum for how aliases should be translated.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum AliasVariation {
     /// Convert to regular Rust alias
-    #[default]
     TypeAlias,
     /// Create a new type by wrapping the old type in a struct and using #[repr(transparent)]
     NewType,
@@ -3814,6 +3823,12 @@ impl fmt::Display for AliasVariation {
     }
 }
 
+impl Default for AliasVariation {
+    fn default() -> AliasVariation {
+        AliasVariation::TypeAlias
+    }
+}
+
 impl std::str::FromStr for AliasVariation {
     type Err = std::io::Error;
 

bindgen/codegen/mod.rs

@@ -9,10 +9,9 @@ use std::cmp;
 use std::ops;
 
 /// The result of the `HasVtableAnalysis` for an individual item.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) enum HasVtableResult {
     /// The item does not have a vtable pointer.
-    #[default]
     No,
 
     /// The item has a vtable and the actual vtable pointer is within this item.
@@ -23,6 +22,12 @@ pub(crate) enum HasVtableResult {
     BaseHasVtable,
 }
 
+impl Default for HasVtableResult {
+    fn default() -> Self {
+        HasVtableResult::No
+    }
+}
+
 impl HasVtableResult {
     /// Take the least upper bound of `self` and `rhs`.
     pub(crate) fn join(self, rhs: Self) -> Self {

bindgen/ir/analysis/has_vtable.rs

@@ -125,17 +125,22 @@ pub(crate) trait MonotoneFramework: Sized + fmt::Debug {
 
 /// Whether an analysis's `constrain` function modified the incremental results
 /// or not.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) enum ConstrainResult {
     /// The incremental results were updated, and the fix-point computation
     /// should continue.
     Changed,
 
     /// The incremental results were not updated.
-    #[default]
     Same,
 }
 
+impl Default for ConstrainResult {
+    fn default() -> Self {
+        ConstrainResult::Same
+    }
+}
+
 impl ops::BitOr for ConstrainResult {
     type Output = Self;
 

bindgen/ir/analysis/mod.rs

@@ -24,14 +24,13 @@ use std::{cmp, ops};
 ///
 /// We initially assume that all types are `ZeroSized` and then update our
 /// understanding as we learn more about each type.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) enum SizednessResult {
     /// The type is zero-sized.
     ///
     /// This means that if it is a C++ type, and is not being used as a base
     /// member, then we must add an `_address` byte to enforce the
     /// unique-address-per-distinct-object-instance rule.
-    #[default]
     ZeroSized,
 
     /// Whether this type is zero-sized or not depends on whether a type
@@ -63,6 +62,12 @@ pub(crate) enum SizednessResult {
     NonZeroSized,
 }
 
+impl Default for SizednessResult {
+    fn default() -> Self {
+        SizednessResult::ZeroSized
+    }
+}
+
 impl SizednessResult {
     /// Take the least upper bound of `self` and `rhs`.
     pub(crate) fn join(self, rhs: Self) -> Self {

bindgen/ir/analysis/sizedness.rs

@@ -9,14 +9,13 @@ use std::str::FromStr;
 use crate::clang;
 
 /// What kind of visibility modifier should be used for a struct or field?
-#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Default)]
+#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
 pub enum FieldVisibilityKind {
     /// Fields are marked as private, i.e., struct Foo {bar: bool}
     Private,
     /// Fields are marked as crate public, i.e., struct Foo {pub(crate) bar: bool}
     PublicCrate,
     /// Fields are marked as public, i.e., struct Foo {pub bar: bool}
-    #[default]
     Public,
 }
 
@@ -45,6 +44,12 @@ impl std::fmt::Display for FieldVisibilityKind {
     }
 }
 
+impl Default for FieldVisibilityKind {
+    fn default() -> Self {
+        FieldVisibilityKind::Public
+    }
+}
+
 /// What kind of accessor should we provide for a field?
 #[derive(Copy, PartialEq, Eq, Clone, Debug)]
 pub(crate) enum FieldAccessorKind {