Add rust language editions support

While not used in this PR, this will allow different code generation depending on the language target, e.g. for rust-lang#2996

Introduce a new `--rust-edition` parameter with allowed values 2015, 2018, 2021, and 2024.

Author: nyurik

bindgen/codegen/mod.rs

@@ -3901,6 +3901,52 @@ impl std::str::FromStr for MacroTypeVariation {
     }
 }
 
+/// Enum for the edition of Rust language to use.
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+pub enum RustEdition {
+    /// Rust 2015 language edition
+    Rust2015,
+    /// Rust 2018 language edition
+    #[default]
+    Rust2018,
+    /// Rust 2021 language edition
+    Rust2021,
+    /// Rust 2024 language edition
+    Rust2024,
+}
+
+impl fmt::Display for RustEdition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Rust2015 => "2015",
+            Self::Rust2018 => "2018",
+            Self::Rust2021 => "2021",
+            Self::Rust2024 => "2024",
+        }.fmt(f)
+    }
+}
+
+impl FromStr for RustEdition {
+    type Err = std::io::Error;
+
+    /// Create a `RustEdition` from a string.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "2015" => Ok(RustEdition::Rust2015),
+            "2018" => Ok(RustEdition::Rust2018),
+            "2021" => Ok(RustEdition::Rust2021),
+            "2024" => Ok(RustEdition::Rust2024),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid language edition. Accepted values ",
+                    "are '2015', '2018', '2021', and '2024'"
+                ),
+            )),
+        }
+    }
+}
+
 /// Enum for how aliases should be translated.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
 pub enum AliasVariation {

bindgen/lib.rs

@@ -75,6 +75,7 @@ use std::process::{Command, Stdio};
 use std::rc::Rc;
 use std::str::FromStr;
 use std::sync::{Arc, OnceLock};
+use crate::codegen::RustEdition;
 
 // Some convenient typedefs for a fast hash map and hash set.
 type HashMap<K, V> = rustc_hash::FxHashMap<K, V>;
@@ -528,6 +529,11 @@ impl BindgenOptions {
         }
     }
 
+    /// Update rust edition version
+    pub fn set_rust_edition(&mut self, rust_edition: RustEdition) {
+        self.rust_edition = rust_edition;
+    }
+
     /// Update rust target version
     pub fn set_rust_target(&mut self, rust_target: RustTarget) {
         self.rust_target = rust_target;

bindgen/options/mod.rs

@@ -8,9 +8,7 @@ mod as_args;
 pub(crate) mod cli;
 
 use crate::callbacks::ParseCallbacks;
-use crate::codegen::{
-    AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
-};
+use crate::codegen::{AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle, RustEdition};
 use crate::deps::DepfileSpec;
 use crate::features::{RustFeatures, RustTarget};
 use crate::regex_set::RegexSet;
@@ -1594,6 +1592,22 @@ options! {
         as_args: |value, args| (!value).as_args(args, "--no-prepend-enum-name"),
     },
     /// Version of the Rust compiler to target.
+    rust_edition: RustEdition {
+        methods: {
+            /// Specify the Rust edition version.
+            ///
+            /// The default edition is the latest stable Rust version.
+            pub fn rust_edition(mut self, rust_edition: RustEdition) -> Self {
+                self.options.set_rust_edition(rust_edition);
+                self
+            }
+        },
+        as_args: |rust_edition, args| {
+            args.push("--rust-edition".to_owned());
+            args.push(rust_edition.to_string());
+        },
+    },
+    /// Version of the Rust compiler to target.
     rust_target: RustTarget {
         methods: {
             /// Specify the Rust target version.