Change:
I wanted to test our handling of slices that are "too big" (bigger than the largest possible allocation), so I wrote: I expected an ICE or so, but I got a timeout. On nightly, here's what a stacktrace looks like: looks like the interning could do with a fast path for integer slices similar to what validation does? And maybe it could also check that the reference is dereferencable before walking it, that would avoid finding out later that we are going to produce an error anyway.
This now finishes in milliseconds with an error:

Discussion:
<ins> // Regression test for #63952, shouldn't hang. use std::usize; #[repr(C)] #[derive(Copy, Clone)] struct SliceRepr { ptr: *const u8, len: usize, } union SliceTransmute { repr: SliceRepr, slice: &'static [u8], } // bad slice: length too big to even exist anywhere const SLICE_WAY_TOO_LONG: &[u8] = unsafe { //~ ERROR: it is undefined behavior to use this value SliceTransmute { repr: SliceRepr { ptr: &42, len: usize::MAX, }, } .slice }; fn main() {} </ins>

<ins> error[E0080]: it is undefined behavior to use this value --> $DIR/issue-63952.rs:18:1 | LL | / const SLICE_WAY_TOO_LONG: &[u8] = unsafe { LL | |     SliceTransmute { LL | |         repr: SliceRepr { LL | |             ptr: &42, ...  | LL | |     .slice LL | | }; | |__^ invalid slice: total size is bigger than largest supported object | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>

<ins> // A regression test for #68653, which was fixed by #68938. // check-pass #![allow(incomplete_features)] #![feature(generic_associated_types)] trait Fun { type F<'a: 'a>; } impl <T> Fun for T { type F<'a> = Self; } fn main() {} </ins>

<ins> #![crate_type = "lib"] pub fn vec() -> Vec<u8> { vec![] } </ins>

<ins> // edition:2018 // aux-build:issue-51798.rs // check-pass extern crate issue_51798; mod server { fn f() { let mut v = issue_51798::vec(); v.clear(); } } fn main() {} </ins>

<ins> // Regression test for #62894, shouldn't crash. // error-pattern: this file contains an unclosed delimiter // error-pattern: expected one of `(`, `[`, or `{`, found keyword `fn` fn f() { assert_eq!(f(), (), assert_eq!(assert_eq! fn main() {} </ins>

<ins> error: this file contains an unclosed delimiter --> $DIR/issue-62894.rs:7:14 | LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq! |        -           -                   - unclosed delimiter |        |           | |        |           unclosed delimiter |        unclosed delimiter LL | LL | fn main() {} |              ^ error: this file contains an unclosed delimiter --> $DIR/issue-62894.rs:7:14 | LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq! |        -           -                   - unclosed delimiter |        |           | |        |           unclosed delimiter |        unclosed delimiter LL | LL | fn main() {} |              ^ error: this file contains an unclosed delimiter --> $DIR/issue-62894.rs:7:14 | LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq! |        -           -                   - unclosed delimiter |        |           | |        |           unclosed delimiter |        unclosed delimiter LL | LL | fn main() {} |              ^ error: expected one of `(`, `[`, or `{`, found keyword `fn` --> $DIR/issue-62894.rs:7:1 | LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq! |                                                   - expected one of `(`, `[`, or `{` LL | LL | fn main() {} | ^^ unexpected token error: aborting due to 4 previous errors </ins>

<ins> // Regression test for #39618, shouldn't crash. // FIXME(JohnTitor): Centril pointed out this looks suspicions, we should revisit here. // More context: https://github.com/rust-lang/rust/pull/69192#discussion_r379846796 // check-pass #![feature(specialization)] trait Foo { fn foo(&self); } trait Bar { fn bar(&self); } impl<T> Bar for T where T: Foo { fn bar(&self) {} } impl<T> Foo for T where T: Bar { fn foo(&self) {} } impl Foo for u64 {} fn main() {} </ins>