Understanding Rust Error E0492

Rust Error E0492: A Borrow of a Constant Containing Interior Mutability

The error E0492 occurs when a borrowed reference is attempted to a constant containing interior mutability. Constants are immutable by nature, but interior mutability allows values to be mutated through shared pointers. This abnormal behavior causes the E0492 error.

Problematic code scenario

use std::sync::atomic::AtomicUsize;

const A: AtomicUsize = AtomicUsize::new(0);
const B: &'static AtomicUsize = &A;
// error: cannot borrow a constant which may contain interior mutability,
//        create a static instead
This code example attempts to borrow a constant containing interior mutability, leading to Rust error E0492.

Solving the Error

To fix this error, use `static` instead of `const` for variables containing interior mutability. This allows for safe mutation of the value in memory.

Corrected Code Example

use std::sync::atomic::AtomicUsize;

static A: AtomicUsize = AtomicUsize::new(0);
static B: &'static AtomicUsize = &A; // ok!
In this example, we replaced `const` with `static`, resolving the error E0492.

Working with Cell Types

The E0492 error can also arise when using cell types, as they perform operations that are not thread-safe. Cell types do not implement the `Sync` trait, so they cannot be used directly as statics. However, this can be circumvented by using an unsafe wrapper.

Unsafe Wrapper Example

use std::cell::Cell;

struct NotThreadSafe<T> {
    value: Cell<T>,

unsafe impl<T> Sync for NotThreadSafe<T> {}

static A: NotThreadSafe<usize> = NotThreadSafe { value : Cell::new(1) };
static B: &'static NotThreadSafe<usize> = &A; // ok!
This code example uses an unsafe wrapper to make a cell type compatible with statics, although synchronization of access must be managed manually.