Recursion limit exceeded on method definition abstract type ascription

[LPTK]

It seems weird that this produces a "Recursion limit exceeded" error:

type M = { type T[+A]; type Ev >: T[Any] <: T[Nothing] }
val M: M = ().asInstanceOf[M]
def dcast(m: M.T[Any]): M.T[Int] = m: M.Ev

[biboudis]

Thanks for reporting @LPTK! Adding here the msg!

def dcast(m: M.T[Any]): M.T[Int] = m: M.Ev
  |                                        ^
  |                   Recursion limit exceeded.
  |                   Maybe there is an illegal cyclic reference?
  |                   If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
  |                   A recurring operation is (inner to outer):
  |
  |                     find-member Object#T
  |                     find-member Object#T
  |                     find-member Object#T
...

[Blaisorblade]

@LPTK is the almost-inconsistent bound necessary to get this crash? (not really inconsistent because M.T could be a constant type constructor, but that’s the only case I think?)

But find-member Object#T should certainly not recurse; it might be trying find-member on Object’s supertype, but then should detect the lack of progress and show the true error.

[LPTK]

Here's a program that demonstrates a similar error; perhaps related, perhaps not.

sbt:dotty> repl
[warn] Multiple main classes detected.  Run show discoveredMainClasses to see the list
[info] Running (fork) dotty.tools.repl.Main -classpath /.ivy2/cache/org.scala-lang/scala-library/jars/scala-library-2.12.8.jar:dotty/library/../out/bootstrap/dotty-library-bootstrapped/scala-0.14/dotty-library_0.14-0.14.0-bin-SNAPSHOT.jar

scala> class A{ type P <: { type T = P_T }; type P_T <: P }
// defined class A

scala> def foo0(p: A): Nothing = foo0(new A) // doesn't crash
def foo0(p: A): Nothing

scala> def foo1(p: A): Nothing = foo1(new A{}) // crashes!
1 |def foo1(p: A): Nothing = foo1(new A{}) // crashes!
  |                               ^
  |Recursion limit exceeded.
  |Maybe there is an illegal cyclic reference?
  |If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
  |A recurring operation is (inner to outer):
  |
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  ...
  |
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P
  |  find-member $anon#P_T
  |  find-member $anon#P

[LPTK]

Here's an even simpler tests case to add for the future:

scala> class A { type G[_]; type F[T] <: G[T] }
     | new A { type F[T]; type G[T] <: F[T] }
     |
2 |new A { type F[T]; type G[T] <: F[T] }
  |^
  |Recursion limit exceeded.
  |Maybe there is an illegal cyclic reference?
  |If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
  |A recurring operation is (inner to outer):
  |
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  ...
  |
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F
  |  find-member A#F

And when I remove all the type parameters, the compiler simply hangs forever, when tried in Dotty's repl sbt command:

class A { type G; type F <: G }
new A { type F; type G <: F}

[steinybot]

Is this the same issue?

import scala.deriving.Mirror
import reflect.Selectable.reflectiveSelectable

trait WithSelf {
  type Self
}

type PersonData = WithSelf {
  val name: String
  def withName(name: String): Self
}

case class Person(name: String) extends WithSelf {
  type Self = Person
  def withName(name: String): Self = copy(name = name)
}

object Main extends App {
  val alice: PersonData = Person("Alice")
  println(alice.name)
  println(alice.withName("Bonnie"))
}

[error] -- Error: /Users/jason/src/bug-reports/src/main/scala/Main.scala:21:16 ---------
[error] 21 |  println(alice.withName("Bonnie"))
[error]    |                ^
[error]    |Recursion limit exceeded.
[error]    |Maybe there is an illegal cyclic reference?
[error]    |If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
[error]    |For the unprocessed stack trace, compile with -Yno-decode-stacktraces.
[error]    |A recurring operation is (inner to outer):
[error]    |
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  ...
[error]    |
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member WithSelf#Self
[error]    |  find-member alice.withName
[error] one error found

[ckipp01]

Just tested the original issue here and it seems to no longer do this:

Welcome to Scala 3.3.1-RC1-bin-20230510-d6c643c-NIGHTLY-git-d6c643c (17.0.5, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala>   type M = { type T[+A]; type Ev >: T[Any] <: T[Nothing] }
     |   val M: M = ().asInstanceOf[M]
     |   def dcast(m: M.T[Any]): M.T[Int] = m: M.Ev
     |
// defined alias type M = {z1 => Object{type T[+A]; type Ev >: z1.T[Any] <: z1.T[Nothing]}}
val M: M = ()
def dcast(m: M.T[Any]): M.T[Int]

Also on nightly the example given by @steinybot also doesn't have any issues. Please do report back if you're still experiencing this in the latest nightly.

[LPTK]

@ckipp01 I think the right thing to do would be to add regression tests before closing the issue.

[ckipp01]

@ckipp01 I think the right thing to do would be to add regression tests before closing the issue.

Yes, you're absolutely correct. I've shot in #17472 for this.