Exponentially expanding type causes monomorphization in compiler to panic or run "forever" #132558
Labels
A-monomorphization
Area: Monomorphization
C-bug
Category: This is a bug.
I-ICE
Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️
I-monomorphization
Issue: An error at monomorphization time.
T-compiler
Relevant to the compiler team, which will review and decide on the PR/issue.
Comments
ntc2
added
C-bug
rustbot
added
the
needs-triage
fmease
added
I-monomorphization
|
rust/compiler/rustc_type_ir/src/ty_kind.rs Lines 795 to 799 in fbab782 interesting. |
|
I wonder if this is another duplicate of #95134 |
|
Below is a simpler example that reproduces the crash/hang, altho it behaves a little bit differently from my original example above: for the version below, the compiler doesn't hang if you manually expand the definition of See comments in code for how some small variations affect the outcome. //#![recursion_limit = "10"]
trait S {
type Child: S;
}
impl<X: S> S for (X, X) {
// Recursing "inwards" here using `X::Child` seems to be
// important. E.g. if I instead define
//
//type Child = ((X, X), (X, X));
//
// which is just as exponential, but not recursive, then the compiler again
// gives the correct "recursion depth exceeded" error with the default and
// small recursion limits.
type Child = (X::Child, X::Child);
}
impl<X: S> S for Box<X> {
type Child = X;
}
type Data = Box<(A, A)>;
struct A {}
impl S for A {
// Manually expanding the `Data::Child` here fixes the bug both for a small
// recursion limit, and for the default recursion limit, i.e. the compiler
// gives a "recursion depth exceeded" error message in both cases. This is
// in contrast to the version above in my report, where expanding the
// `Data::Child` type fixes the bug for the small recursion limit, but the
// compiler still hangs for the default recursion limit.
//
//type Child = (A, A);
type Child = <Data as S>::Child;
}
fn uhoh<T: S>() {
uhoh::<T::Child>();
}
fn main() {
uhoh::<A>();
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
The below code causes the compiler to panic or run forever, depending on how large the compiler
recursion_limitsetting is.Here's a summary of code below: I have a trait
Swith associated typeS::Child: S, and I define a structA: SwithA::Child = (A,A), and I define(X,X)::Child = (X::Child, X::Child). I define a functionuhoh<T: S>(x:T)that recurses onuhoh::<T::Child>, and so trying to calluhoh::<A>results in the compiler needing to monomorphize at typeA,A::Child = (A,A),A::Child::Child = ((A,A),(A,A))etc, ad infinitum. Instead of giving an error as I would expect, the compiler panics or runs forever, depending on how largerecursion_limitis.The below code is a minimal reproduction of a real problem I ran into into a private code base.
Code
Single file reproduction, just run with
cargo run:Meta
I encountered the real problem on 1.80.1, and tested the minimal reproduction above on 1.80.1, 1.82.0, and 1.84.0-nightly. I.e.
rustc --version --verbose:and
and
Error output
Here's the output of
cargo buildon 1.84.0-nightly, with backtrace and huge type elided:Panic message asked me to attach this:
rustc-ice-2024-11-03T12_59_37-2130395.txt
Backtrace
The text was updated successfully, but these errors were encountered: