Add test for cyclic references involving members of inherited and intersected types

Test every template and every type intersection for cycles in its members.
The tests are done as early possible without causing spurious cycles,
which for intersections means PostTyper, unfortunately.
Still missing: Do the test also for members reachable in common value definitions.

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -4560,8 +4560,15 @@ object Types {
     if (ctx.debug) printStackTrace()
   }
 
+  def showPrefixSafely(pre: Type)(implicit ctx: Context): String = pre.stripTypeVar match {
+    case pre: TermRef => i"${pre.termSymbol.name}."
+    case pre: TypeRef => i"${pre.typeSymbol.name}#"
+    case pre: TypeProxy => showPrefixSafely(pre.underlying)
+    case _ => if (pre.typeSymbol.exists) i"${pre.typeSymbol.name}#" else "."
+  }
+
   class CyclicFindMember(pre: Type, name: Name)(implicit ctx: Context) extends TypeError(
-    i"""member search with prefix $pre too deep.
+    i"""member search for ${showPrefixSafely(pre)}$name too deep.
        |searches, from inner to outer: .${ctx.pendingMemberSearches}% .%""")
 
   private def otherReason(pre: Type)(implicit ctx: Context): String = pre match {

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -285,6 +285,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               case tpe => tpe
             }
           )
+        case tree: AndTypeTree =>
+          // Ideally, this should be done by Typer, but we run into cyclic references
+          // when trying to typecheck self types which are intersections.
+          Checking.checkNonCyclicInherited(tree.tpe, tree.left.tpe :: tree.right.tpe :: Nil, EmptyScope, tree.pos)
+          super.transform(tree)
         case Import(expr, selectors) =>
           val exprTpe = expr.tpe
           val seen = mutable.Set.empty[Name]

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -332,6 +332,36 @@ object Checking {
     checkTree((), refinement)
   }
 
+  /** Check type members inherited from different `parents` of `joint` type for cycles,
+   *  unless a type with the same name aleadry appears in `decls`.
+   *  @return    true iff no cycles were detected
+   */
+  def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: Position)(implicit ctx: Context): Unit = {
+    def qualifies(sym: Symbol) = sym.name.isTypeName && !sym.is(Private)
+    val abstractTypeNames =
+      for (parent <- parents; mbr <- parent.abstractTypeMembers if qualifies(mbr.symbol))
+      yield mbr.name.asTypeName
+
+   for (name <- abstractTypeNames)
+      try {
+        val mbr = joint.member(name)
+        mbr.info match {
+          case bounds: TypeBounds =>
+            val res = checkNonCyclic(mbr.symbol, bounds, reportErrors = true).isError
+            if (res)
+              println(i"cyclic ${mbr.symbol}, $bounds -> $res")
+            res
+          case _ =>
+            false
+        }
+      }
+      catch {
+        case ex: CyclicFindMember =>
+          ctx.error(em"cyclic reference involving type $name", pos)
+          true
+      }
+  }
+
   /** Check that symbol's definition is well-formed. */
   def checkWellFormed(sym: Symbol)(implicit ctx: Context): Unit = {
     def fail(msg: Message) = ctx.error(msg, sym.pos)
@@ -528,6 +558,9 @@ trait Checking {
   def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(implicit ctx: Context): Type =
     Checking.checkNonCyclic(sym, info, reportErrors)
 
+  def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: Position)(implicit ctx: Context): Unit =
+    Checking.checkNonCyclicInherited(joint, parents, decls, pos)
+
   /** Check that Java statics and packages can only be used in selections.
    */
   def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = {
@@ -866,6 +899,7 @@ trait ReChecking extends Checking {
 trait NoChecking extends ReChecking {
   import tpd._
   override def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(implicit ctx: Context): Type = info
+  override def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree
   override def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkClassType(tp: Type, pos: Position, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type = tp

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1547,6 +1547,8 @@ class Typer extends Namer
           cls, isRequired, cdef.pos)
       }
 
+      checkNonCyclicInherited(cls.thisType, cls.classParents, cls.info.decls, cdef.pos)
+
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 

tests/run/returning.scala

@@ -0,0 +1,53 @@
+package scala.util.control {
+
+object NonLocalReturns {
+
+  class ReturnThrowable[T] extends ControlThrowable {
+    private var myResult: T = _
+    def throwReturn(result: T): Nothing = {
+      myResult = result
+      throw this
+    }
+    def result: T = myResult
+  }
+
+  def throwReturn[T](result: T)(implicit returner: ReturnThrowable[T]): Nothing =
+    returner.throwReturn(result)
+
+  def returning[T](op: implicit ReturnThrowable[T] => T): T = {
+    val returner = new ReturnThrowable[T]
+    try op(returner)
+    catch {
+      case ex: ReturnThrowable[_] =>
+       if (ex `eq` returner) ex.result.asInstanceOf[T] else throw ex
+    }
+  }
+}
+}
+
+object Test extends App {
+
+  import scala.util.control.NonLocalReturns._
+  import scala.collection.mutable.ListBuffer
+
+  def has(xs: List[Int], elem: Int) =
+    returning {
+      for (x <- xs)
+        if (x == elem) throwReturn(true)
+      false
+    }
+
+  def takeUntil(xs: List[Int], elem: Int) =
+    returning {
+      var buf = new ListBuffer[Int]
+      for (x <- xs)
+      yield {
+        if (x == elem) throwReturn(buf.toList)
+        buf += x
+        x
+      }
+    }
+
+  assert(has(List(1, 2, 3), 2))
+  assert(takeUntil(List(1, 2, 3), 3) == List(1, 2))
+}