Merge remote-tracking branch 'origin/main' into mimalloc

Author: mtreinish

Cargo.lock

@@ -59,6 +59,7 @@ qiskit-cext = { path = "crates/cext" }
 qiskit-cext-vtable = { path = "crates/cext-vtable" }
 qiskit-circuit = { path = "crates/circuit" }
 qiskit-circuit-library = { path = "crates/circuit_library" }
+qiskit-providers = { path = "crates/providers" }
 qiskit-qasm2 = { path = "crates/qasm2" }
 qiskit-qasm3 = { path = "crates/qasm3" }
 qiskit-qpy = { path = "crates/qpy" }

Cargo.toml

@@ -30,6 +30,8 @@ The intention is that (much) longer term, we might be wanting to expose more of
 * `qiskit-synthesis` is the crate for synthesis functionality.
 * `qiskit-circuit-library` is the crate for circuit library functions. It contains constructors or other
   circuit functionality that builds on the core circuit data model defined in `qiskit-circuit`.
+* `qiskit-providers` is the crate that defines the providers interface for Qiskit. The providers interface is what defines the concept of a Backend.
+  The backend models a quantum computer, which is the QPU and the infrastructure around it required to execute circuits on the quantum computer.
 * `qiskit-util` is for small utility functions and data structures that are independent of all
   Qiskit-specific objects, so it can be depended-on by both `quantum-info` and `circuit`.
 

crates/README.md

@@ -14,4 +14,5 @@ name = "qiskit_bindgen"
 
 [dependencies]
 anyhow.workspace = true
-cbindgen.workspace = true
+cbindgen  = { workspace = true, features = ["unstable_ir"] }
+hashbrown.workspace = true

crates/bindgen/Cargo.toml

@@ -10,6 +10,8 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+pub mod render;
+
 use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};

crates/bindgen/src/lib.rs

@@ -0,0 +1,91 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2026
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use cbindgen::bindgen::ir;
+use hashbrown::HashMap;
+
+/// Render a given type object into a string representing it in C.
+fn render_type(ty: &ir::Type, config: &cbindgen::Config) -> String {
+    fn render(ty: &ir::Type, config: &cbindgen::Config, acc: &mut String) {
+        match ty {
+            ir::Type::Ptr {
+                ty,
+                is_const,
+                is_nullable: _,
+                is_ref,
+            } => {
+                assert!(!is_ref, "C++ reference-likes not handled");
+                if *is_const {
+                    acc.push_str("const ");
+                }
+                render(ty, config, acc);
+                acc.push_str(" *");
+            }
+            ir::Type::Path(p) => acc.push_str(p.export_name()),
+            ir::Type::Primitive(ty) => acc.push_str(ty.to_repr_c(config)),
+            ir::Type::Array(..) => todo!("array types not yet handled"),
+            ir::Type::FuncPtr {
+                args,
+                ret,
+                is_nullable,
+                never_return,
+            } => {
+                assert!(!is_nullable, "nullability of funcptrs is not handled");
+                assert!(!never_return, "diverging functions not handled");
+                render(ret, config, acc);
+                acc.push_str("(*)(");
+                let mut args = args.iter();
+                if let Some((_, first)) = args.next() {
+                    render(first, config, acc);
+                    for (_, arg) in args {
+                        acc.push_str(", ");
+                        render(arg, config, acc)
+                    }
+                }
+                acc.push(')');
+            }
+        }
+    }
+    let mut acc = String::new();
+    render(ty, config, &mut acc);
+    acc
+}
+
+/// Calculate a mapping of exported function names to C casts to appropriate function-pointer types.
+pub fn functions_as_funcptr_casts(bindings: &cbindgen::Bindings) -> HashMap<&str, String> {
+    let to_funcptr = |func: &ir::Function| {
+        let to_funcptr_arg = |arg: &ir::FunctionArgument| {
+            let ir::FunctionArgument {
+                name: _,
+                ty,
+                array_length,
+            } = arg;
+            assert!(array_length.is_none(), "array arguments not handled");
+            (None, ty.clone())
+        };
+        ir::Type::FuncPtr {
+            ret: Box::new(func.ret.clone()),
+            args: func.args.iter().map(to_funcptr_arg).collect(),
+            is_nullable: false,
+            never_return: false,
+        }
+    };
+    let config = &bindings.config;
+    bindings
+        .functions
+        .iter()
+        .map(|func| {
+            let funcptr = to_funcptr(func);
+            (func.path.name(), render_type(&funcptr, config))
+        })
+        .collect()
+}

crates/bindgen/src/render/c.rs

@@ -0,0 +1,13 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2026
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+pub mod c;

crates/bindgen/src/render/mod.rs

@@ -171,7 +171,7 @@ pub struct TranspileOptions {
     /// The seed for the transpiler. If set to a negative number this means no seed will be
     /// set and the RNGs used in the transpiler will be seeded from system entropy.
     seed: i64,
-    /// The approximation degree a heurstic dial where 1.0 means no approximation (up to numerical
+    /// The approximation degree a heuristic dial where 1.0 means no approximation (up to numerical
     /// tolerance) and 0.0 means the maximum approximation. A `NAN` value indicates that
     /// approximation is allowed up to the reported error rate for an operation in the target.
     approximation_degree: f64,

crates/cext/src/transpiler/transpile_function.rs

@@ -33,6 +33,8 @@ nom-language.workspace = true
 crossterm = "0.29.0"
 unicode-width = "0.2"
 unicode-segmentation = "1.13"
+lexical-core = "1.0.6"
+lexical-write-float = "1.0.6"
 
 [dependencies.pyo3]
 workspace = true