C# backend

.github/workflows/cbindgen.yml

@@ -60,6 +60,17 @@ jobs:
         python -m pip install --upgrade pip wheel
         pip install Cython==3.0.2
 
+    - name: Install dotnet
+      id: dotnet
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '7.0.302' # dotnet 7.0.302 is used by Unity 2021.3.39f1, 2022.3.33f1, 2023.2.20f1 and 6000.0.5f1
+
+    - name: Get dotnet version
+      run: |
+        DOTNET_VERSION=${{ steps.dotnet.outputs.dotnet-version }}
+        echo "DOTNET_VERSION=${DOTNET_VERSION}" >> $GITHUB_ENV
+
     - name: Build
       run: |
         cargo +stable build --verbose

Cargo.toml

@@ -38,6 +38,7 @@ features = ["clone-impls", "extra-traits", "fold", "full", "parsing", "printing"
 [dev-dependencies]
 serial_test = { version = "2.0.0", default-features = false }
 pretty_assertions = "1.4.0"
+which = "4"
 
 [features]
 default =  ["clap"]

rust-toolchain.toml

@@ -1,2 +1,3 @@
 [toolchain]
-channel = "nightly"
+channel = "nightly"
+components = ["rustfmt", "clippy"]

src/bindgen/bindings.rs

@@ -16,7 +16,7 @@ use crate::bindgen::ir::{
     Constant, Function, ItemContainer, ItemMap, Path as BindgenPath, Static, Struct, Type, Typedef,
 };
 use crate::bindgen::language_backend::{
-    CLikeLanguageBackend, CythonLanguageBackend, LanguageBackend,
+    CLikeLanguageBackend, CSharpLanguageBackend, CythonLanguageBackend, LanguageBackend,
 };
 use crate::bindgen::writer::SourceWriter;
 
@@ -37,6 +37,7 @@ pub struct Bindings {
     /// and shouldn't do anything when written anywhere.
     noop: bool,
     pub package_version: String,
+    binding_crate_lib_name: String,
 }
 
 impl Bindings {
@@ -52,6 +53,7 @@ impl Bindings {
         source_files: Vec<path::PathBuf>,
         noop: bool,
         package_version: String,
+        binding_crate_lib_name: String,
     ) -> Bindings {
         Bindings {
             config,
@@ -65,6 +67,7 @@ impl Bindings {
             source_files,
             noop,
             package_version,
+            binding_crate_lib_name,
         }
     }
 
@@ -210,6 +213,9 @@ impl Bindings {
             Language::Cython => {
                 self.write_with_backend(file, &mut CythonLanguageBackend::new(&self.config))
             }
+            Language::CSharp => {
+                self.write_with_backend(file, &mut CSharpLanguageBackend::new(&self.config))
+            }
         }
     }
 

src/bindgen/builder.rs

@@ -362,6 +362,7 @@ impl Builder {
                 Default::default(),
                 true,
                 String::new(),
+                Default::default(),
             ));
         }
 
@@ -375,6 +376,8 @@ impl Builder {
             result.extend_with(&parser::parse_src(x, &self.config)?);
         }
 
+        let binding_crate_lib_name;
+
         if let Some((lib_dir, binding_lib_name)) = self.lib.clone() {
             let lockfile = self.lockfile.as_deref();
 
@@ -388,9 +391,14 @@ impl Builder {
                 /* existing_metadata = */ None,
             )?;
 
+            binding_crate_lib_name = cargo.binding_crate_lib_name().to_string();
+
             result.extend_with(&parser::parse_lib(cargo, &self.config)?);
         } else if let Some(cargo) = self.lib_cargo.clone() {
+            binding_crate_lib_name = cargo.binding_crate_lib_name().to_string();
             result.extend_with(&parser::parse_lib(cargo, &self.config)?);
+        } else {
+            binding_crate_lib_name = String::new()
         }
 
         result.source_files.extend_from_slice(self.srcs.as_slice());
@@ -407,6 +415,7 @@ impl Builder {
             result.functions,
             result.source_files,
             result.package_version,
+            binding_crate_lib_name,
         )
         .generate()
     }

src/bindgen/cargo/cargo.rs

@@ -25,6 +25,7 @@ fn parse_dep_string(dep_string: &str) -> (&str, Option<&str>) {
 pub(crate) struct Cargo {
     manifest_path: PathBuf,
     binding_crate_name: String,
+    binding_crate_lib_name: String,
     lock: Option<Lock>,
     metadata: Metadata,
     clean: bool,
@@ -63,25 +64,34 @@ impl Cargo {
             None
         };
 
+        let manifest = cargo_toml::manifest(&toml_path)
+            .map_err(|x| Error::CargoToml(toml_path.to_str().unwrap().to_owned(), x))?;
+
         // Use the specified binding crate name or infer it from the manifest
         let binding_crate_name = match binding_crate_name {
             Some(s) => s.to_owned(),
-            None => {
-                let manifest = cargo_toml::manifest(&toml_path)
-                    .map_err(|x| Error::CargoToml(toml_path.to_str().unwrap().to_owned(), x))?;
-                manifest.package.name
-            }
+            None => manifest.package.name,
         };
 
+        let binding_crate_lib_name = manifest
+            .lib
+            .and_then(|lib| lib.name)
+            .unwrap_or_else(|| binding_crate_name.clone());
+
         Ok(Cargo {
             manifest_path: toml_path,
             binding_crate_name,
+            binding_crate_lib_name,
             lock,
             metadata,
             clean,
         })
     }
 
+    pub(crate) fn binding_crate_lib_name(&self) -> &str {
+        &self.binding_crate_lib_name
+    }
+
     pub(crate) fn binding_crate_name(&self) -> &str {
         &self.binding_crate_name
     }

src/bindgen/cargo/cargo_toml.rs

@@ -50,13 +50,19 @@ impl error::Error for Error {
 #[derive(Clone, Deserialize, Debug)]
 pub struct Manifest {
     pub package: Package,
+    pub lib: Option<Lib>,
 }
 
 #[derive(Clone, Deserialize, Debug)]
 pub struct Package {
     pub name: String,
 }
 
+#[derive(Clone, Deserialize, Debug)]
+pub struct Lib {
+    pub name: Option<String>,
+}
+
 /// Parse the Cargo.toml for a given path
 pub fn manifest(manifest_path: &Path) -> Result<Manifest, Error> {
     let mut s = String::new();

src/bindgen/config.rs

@@ -23,6 +23,7 @@ pub enum Language {
     Cxx,
     C,
     Cython,
+    CSharp,
 }
 
 impl FromStr for Language {
@@ -42,6 +43,12 @@ impl FromStr for Language {
             "C" => Ok(Language::C),
             "cython" => Ok(Language::Cython),
             "Cython" => Ok(Language::Cython),
+            "csharp" => Ok(Language::CSharp),
+            "Csharp" => Ok(Language::CSharp),
+            "CSharp" => Ok(Language::CSharp),
+            "CSHARP" => Ok(Language::CSharp),
+            "c#" => Ok(Language::CSharp),
+            "C#" => Ok(Language::CSharp),
             _ => Err(format!("Unrecognized Language: '{}'.", s)),
         }
     }
@@ -54,6 +61,7 @@ impl Language {
         match self {
             Language::Cxx | Language::C => "typedef",
             Language::Cython => "ctypedef",
+            Language::CSharp => "using",
         }
     }
 }
@@ -894,6 +902,22 @@ pub struct CythonConfig {
     pub cimports: BTreeMap<String, Vec<String>>,
 }
 
+/// Settings specific to C# bindings.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct CSharpConfig {
+    /// Package to use
+    pub package: Option<String>,
+
+    /// Name of the generated interface
+    pub interface_name: Option<String>,
+
+    /// Extra definition to include inside the generated interface
+    pub extra_defs: Option<String>,
+}
+
 /// A collection of settings to customize the generated bindings.
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -1016,6 +1040,8 @@ pub struct Config {
     /// via the CLI, when ran from a build script cargo sets this variable
     /// appropriately).
     pub only_target_dependencies: bool,
+    /// Configuration options specific to C#.
+    pub csharp: CSharpConfig,
     /// Configuration options specific to Cython.
     pub cython: CythonConfig,
     #[doc(hidden)]
@@ -1069,6 +1095,7 @@ impl Default for Config {
             documentation_length: DocumentationLength::Full,
             pointer: PtrConfig::default(),
             only_target_dependencies: false,
+            csharp: CSharpConfig::default(),
             cython: CythonConfig::default(),
             config_path: None,
         }

src/bindgen/ir/constant.rs

@@ -721,6 +721,22 @@ impl Constant {
                 write!(out, " {} # = ", name);
                 language_backend.write_literal(out, value);
             }
+            Language::CSharp => {
+                // if java_writable_literal(&self.ty, value) {
+                //     out.write("public static final ");
+                //     language_backend.write_type(out, &self.ty);
+                //     write!(out, " {}  = ", self.export_name);
+                //     language_backend.write_literal(out, &wrap_java_value(value, &self.ty));
+                //     out.write(";")
+                // } else {
+                //     write!(
+                //         out,
+                //         "/* Unsupported literal for constant {} */",
+                //         self.export_name
+                //     )
+                // }
+                out.new_line();
+            }
         }
 
         condition.write_after(config, out);