Compiler hangs on infinite match type reduction

class P[X, Y]

type Swap[X] = X match
  case P[x, y] => Swap[P[y, x]]

val z: P[String, Int] = ??? : Swap[P[Int, String]]

The compiler seems to hang when compiling the last line.

Expectation

The compiler should either report a stack overflow or detect the diverging expansion statically. My preference would be to try static divergence detection first. @milessabin implemented state of the art techniques for detecting divergent implicit searches - it seems that these techniques are transferable.

[milessabin]

There’s a detailed description of the divergence checking algorithm along with a termination proof in the by-name implicits SIP. See here for what I implemented in dotty and scalac … see also the descriptions just above of the previous scalac algorithm and the even earlier version described in the SLS.

I think a manually configured compile time option isn’t a good idea because the user has no idea how to set it other than by increasing it until the compilation is successful or until they get bored. In the case of implicit resolution, deeply buried failures can be hidden by an overall failure, so an implicit resolution step limit would be extremely confusing for users. I’m not sure to what extent that would carry over to this case, but in general these sort of limits are unhelpful.

If you are able to use this algorithm for match type reduction, then we have a termination proof, so we’re not trying to prevent an infinite loop. That being the case I think it’s better to run without a manual bound and let users hit ctrl-c when they get tired of waiting.

[odersky]

If the checks in question can have false negative (i.e. they can fail to detect infinite reductions), then we probably want to back them up with a bound to catch those cases.

Actually, no they do not have a false negative.