Remove need for mutable reference to static

[jakelishman]

Mutable references to static data are inherently unsafe and typically unsound in Rust, because statics are implicitly shared between threads, and the borrow checker can only enforce the shared/exclusive reference limitations within a single thread here.

This just moves the thread-exclusion logic into the individual elements of the static, where the GILOnceCell can correctly handle the runtime exclusion of multiple threads. (The GIL is no longer suitable for thread exclusion if we were doing a freethreaded Python build, but that's a problem we have all over Qiskit, and would need to change to OnceLock or the like.)

Summary

Details and comments

Minor conflict with the update to PyO3 0.23, but only a small syntactic one - the import_bound becomes import. The logic still works.

[qiskit-bot]

One or more of the following people are relevant to this code:

• @Qiskit/terra-core

[coveralls]

Pull Request Test Coverage Report for Build 12891354532

Details

• 6 of 6 (100.0%) changed or added relevant lines in 2 files are covered.
• 14 unchanged lines in 3 files lost coverage.
• Overall coverage decreased (-0.002%) to 88.925%

---

Files with Coverage Reduction	New Missed Lines	%
crates/qasm2/src/lex.rs	1	93.48%
crates/accelerate/src/two_qubit_decompose.rs	1	92.06%
crates/qasm2/src/parse.rs	12	97.15%

Totals
Change from base Build 12891072018:	-0.002%
Covered Lines:	79444
Relevant Lines:	89338

---

💛 - Coveralls

[mtreinish]

This LGTM. I think I found the previous code cleaner but rust 1.84 warns 3 times about this being unsafe, and rust edition 2024 will actually make the mut ref static stuff unsafe. While we won't be using that for 2.x, it's good to remove the mut ref static preemptively.

[mtreinish]

This is pretty ugly. But I don't think there is a syntax that we can use here with GilOnceCell given the constraints defined in: https://doc.rust-lang.org/std/primitive.array.html so this is fine.

[jakelishman]

Yeah, it's ugly. For anybody from the future looking: the trouble is that there's not enough available in const functions to manage this. The closest I managed to get was

use std::mem::MaybeUninit;
use pyo3::prelude::*;
use pyo3::sync::GILOnceCell;

const STANDARD_GATE_SIZE: usize = 52;

static STDGATE_PYTHON_GATES: [GILOnceCell<Py<PyAny>>; STANDARD_GATE_SIZE] = const {
    let mut out: [MaybeUninit<GILOnceCell<Py<PyAny>>>; STANDARD_GATE_SIZE] =
        [const { MaybeUninit::uninit() }; STANDARD_GATE_SIZE];
    let mut i = 0;
    while i < STANDARD_GATE_SIZE {
        out[i].write(GILOnceCell::new());  // error: `MaybeUninit::write` isn't const stable
        i += 1;
    }
    unsafe { ::std::mem::transmute(out) }
};