constify Option methods

[oli-obk]

r? @fee1-dead

tracking issue: #143956

these unblock making PartialOrd and Ord const without resorting to inlining some of these at call sites.

[oli-obk]

This pattern was introduced in #116481 because it optimizes better.

[fee1-dead]

I have a feeling this will nerdsnipe me hard.

Here's how code is currently generated

#![feature(const_destruct)]
#![feature(const_trait_impl)]

use std::marker::Destruct;

pub const fn opt_or_else<T, F>(this: Option<T>, f: F) -> Option<T>
where
    F: ~const Destruct + ~const FnOnce() -> Option<T>,
    T: ~const Destruct
{
    match this {
        x @ Some(_) => x,
        None => f()
    }
}

// MIR FOR CTFE
fn opt_or_else(_1: Option<T>, _2: F) -> Option<T> {
    debug this => _1;
    debug f => _2;
    let mut _0: std::option::Option<T>;
    let mut _3: isize;
    let _4: std::option::Option<T>;
    let mut _5: F;
    let mut _6: ();
    let mut _7: bool;
    let mut _8: bool;
    scope 1 {
        debug x => _4;
    }

    bb0: {
        _8 = const false;
        _7 = const false;
        _8 = const true;
        _7 = const true;
        _3 = discriminant(_1);
        switchInt(move _3) -> [0: bb2, 1: bb3, otherwise: bb1];
    }

    bb1: {
        unreachable;
    }

    bb2: {
        StorageLive(_5);
        _7 = const false;
        _5 = move _2;
        StorageLive(_6);
        _6 = ();
        ConstEvalCounter;
        _0 = <F as FnOnce<()>>::call_once(move _5, move _6) -> [return: bb4, unwind: bb12];
    }

    bb3: {
        StorageLive(_4);
        _8 = const false;
        _4 = move _1;
        _0 = move _4;
        StorageDead(_4);
        goto -> bb9;
    }

    bb4: {
        StorageDead(_6);
        StorageDead(_5);
        goto -> bb9;
    }

    bb5: {
        switchInt(copy _8) -> [0: bb6, otherwise: bb10];
    }

    bb6: {
        return;
    }

    bb7 (cleanup): {
        resume;
    }

    bb8: {
        drop(_2) -> [return: bb5, unwind: bb12];
    }

    bb9: {
        switchInt(copy _7) -> [0: bb5, otherwise: bb8];
    }

    bb10: {
        drop(_1) -> [return: bb6, unwind: bb7];
    }

    bb11 (cleanup): {
        drop(_1) -> [return: bb7, unwind terminate(cleanup)];
    }

    bb12 (cleanup): {
        switchInt(copy _8) -> [0: bb7, otherwise: bb11];
    }
}

looks like it tries to drop self at the None arm, which is just weird.

[fee1-dead]

r=me after nit

[fee1-dead]

I think we should put FnOnce first, here and elsewhere in the PR. the destruct bound is noisy and likely to make it harder for someone to read the code.

[oli-obk]

@bors r=fee1-dead

[bors]

📌 Commit 853333d has been approved by fee1-dead

It is now in the queue for this repository.