Stabilization Report

This PR serves as a request for stabilization for three const evaluation features:

1. const_fn_fn_ptr_basics
2. const_fn_trait_bound
3. const_impl_trait

These are being stabilized together because they are relatively minor and related updates to existing functionality.

const_fn_fn_ptr_basics

Allows creating, passing, and casting function pointers in a const fn.

The following is an example of what is now allowed:

const fn get_function() -> fn() {
    fn foo() {
        println!("Hello, World!");
    }
    
    foo
}

Casts between function pointer types are allowed, as well as transmuting from integers:

const fn get_function() -> fn() {
    unsafe {
        std::mem::transmute(0x1234usize)
    }
}

However, casting from a function pointer to an integer is not allowed:

const fn fn_to_usize(f: fn()) -> usize {
    f as usize  //~ pointers cannot be cast to integers during const eval
}

Calling function pointers is also not allowed.

const fn call_fn_ptr(f: fn()) {
    f() //~ function pointers are not allowed in const fn 
}

Test Coverage

The following tests include code that exercises this feature:

• src/test/ui/consts/issue-37550.rs
• src/test/ui/consts/issue-46553.rs
• src/test/ui/consts/issue-56164.rs
• src/test/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs
• src/test/ui/consts/min_const_fn/cast_fn.rs
• src/test/ui/consts/min_const_fn/cmp_fn_pointers.rs

const_fn_trait_bound

Allows trait bounds in const fn. Additionally, this feature allows creating and passing dyn Trait objects.

Examples such as the following are allowed by this feature:

const fn do_thing<T: Foo>(_x: &T) {
    // ...
}

Previously only Sized was allowed as a trait bound.

There is no way to call methods from the trait because trait methods cannot currently be marked as const. Allowing trait bounds in const functions does allow the const function to use the trait's associated types and constants.

This feature also allowes dyn Trait types. These work equivalently to non-const code. Similar to other pointers in const code, the value of a dyn Trait pointer cannot be observed.

Note that due to #90912, it was already possible to do the example above as follows:

const fn do_thing<T>(_x: &T) where (T,): Foo {
    // ...
}

Test Coverage

The following tests include code that exercises const_fn_trait_bound:

• src/test/ui/consts/const-fn.rs
• src/test/ui/consts/issue-88071.rs
• src/test/ui/consts/min_const_fn/min_const_fn.rs
• src/test/ui/consts/min_const_fn/min_const_fn_dyn.rs
• src/test/ui/nll/issue-55825-const-fn.rs
• Many of the tests in src/test/ui/rfc-2632-const-trait-impl/ also exercise this feature.

const_impl_trait

Allows argument and return position impl Trait in a const fn, such as in the following example:

const fn do_thing(x: impl Foo) -> impl Foo {
    x
}

Similar to generic parameters and function pointers, this allows the creation of such opaque types, but not doing anything with them beyond accessing associated types and constants.

Test Coverage

The following tests exercise this feature:

• src/test/ui/type-alias-impl-trait/issue-53096.rs
• src/test/ui/type-alias-impl-trait/issue-53678-generator-and-const-fn.rs

Documentation

These features are documented along with the other const evaluation features in the Rust Reference at https://doc.rust-lang.org/stable/reference/const_eval.html.

There is a PR that updates this documentation to reflect the capabilities enabled by these features at rust-lang/reference#1166.

Tracking issues: #57563, #63997, #93706