`handle_opaque_type_uses` happens after fallback

[lcnr]

causing this test to fail with the new solver

#[derive(Clone, Copy)]
struct FileSystem;
impl FileSystem {
    fn build<T>(self, commands: T) -> Option<impl Sized> {
        match false {
            true => Some(commands),
            false => {
                drop(match self.build::<_>(commands) {
                    Some(x) => x,
                    None => return None,
                });
                panic!()
            },
        }
    }
}

i don't understand how fallback works :3

[lcnr]

easier example

fn build<T, U>() -> impl Sized {
    if false {
        build::<U, T>()
    } else {
        loop {}
    };
    1u32
}

the issue is not that this fallback is confusing, but that the opaque type storage is. For the above example, we need to normalize the opaque types before equating the function arguments

struct W<T>(T);
fn build<T: Default>(commands: T) -> W<impl Sized> {
    return W(commands);
    let mut other_stuff = Default::default();
    [build(other_stuff).0, loop {}];
    other_stuff = commands;
}

[lcnr]

easiest example is by just using region vars

fn build<'a>() -> impl Sized {
    if false {
        build()
    } else {
        loop {}
    };
    1u32
}

[jackh726]

easiest example is by just using region vars

fn build<'a>() -> impl Sized {
if false {
build()
} else {
loop {}
};
1u32
}

FWIW, this actually just compiled for me with -Znext-solver - the test in OP (maybe others, didn't check) do fail.

[lcnr]

it relies on edition>2024 to get impl Sized to capture 'a, maybe change it explicitly use<'a> 😁