#![feature(trivial_bounds)] allows invalid code to compile

[Aaron1011]

The following code compiles:

#![feature(trivial_bounds)]

struct NotCopy;

fn weird() -> NotCopy where NotCopy: Copy {
    *&NotCopy // Should not compile
}

despite the fact that we are moving out of a reference to a !Copy type.

I don't think this can actually lead to unsoundness, since it's impossible to actually call weird. However, I would still expect type-checking to not attempt to assume that trivially false bounds are actually true.

[Aaron1011]

In #67696, this leads to the const evaluator getting confused, since it's attempting to evaluate code that should never have actually compiled.

[cramertj]

FWIW I wouldn't have considered this example a bug-- it's exactly what I thought the trivial_bounds feature was supposed to allow. I'd have expected this to compile just fine, but for weird to be uncallable.

[Aaron1011]

I thought trivial_bounds was just supposed to allow writing trivially true or trivially false where clauses. Whether or not something like NotCopy: Copy holds is a global property of the program, so it seems very surprising that you can 'pretend' that it does within a particular function.

[cramertj]

Inside the body of the function, all where clauses and other bounds on that function should be considered true. This is crucial to trivial_bounds being useful for one of its primary intended purposes: using the trivial bounds as guards on generated code.

[joshtriplett]

Just discovered this issue. I agree that this is exactly how trivial_bounds should work: it should assume the bound is true within the function, and then the function should only be callable if the bound is true.