Rearrange TypeError exceptions

 - Move them all to TypeErrors.scala
 - Systematically use `toMessage` for reporting
 - Catch stack overflows instead of counting recursions

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -74,7 +74,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val XmainClass = StringSetting("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
   val XnoValueClasses = BooleanSetting("-Xno-value-classes", "Do not use value classes. Helps debugging.")
   val XreplLineWidth = IntSetting("-Xrepl-line-width", "Maximal number of columns per line for REPL output", 390)
-  val XmaxMemberRecursions = IntSetting("-Xmax-member-recursions", "Maximal number of recursive calls to find-member", 100)
   val XfatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.")
   val XverifySignatures = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.")
 

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

@@ -20,7 +20,6 @@ import util.Positions.{Position, NoPosition}
 import util.Stats._
 import util.{DotClass, SimpleIdentitySet}
 import reporting.diagnostic.Message
-import reporting.diagnostic.messages.CyclicReferenceInvolving
 import ast.tpd._
 import ast.TreeTypeMap
 import printing.Texts._
@@ -32,10 +31,9 @@ import Uniques._
 import collection.{mutable, Seq, breakOut}
 import config.Config
 import annotation.tailrec
-import Flags.FlagSet
 import language.implicitConversions
 import scala.util.hashing.{ MurmurHash3 => hashing }
-import config.Printers.{core, typr, cyclicErrors}
+import config.Printers.{core, typr}
 import java.lang.ref.WeakReference
 
 object Types {
@@ -647,17 +645,14 @@ object Types {
       }
 
       val recCount = ctx.findMemberCount
-      if (recCount >= Config.LogPendingFindMemberThreshold) {
-        if (ctx.findMemberCount > ctx.settings.XmaxMemberRecursions.value)
-          throw new CyclicFindMember(pre, name)
+      if (recCount >= Config.LogPendingFindMemberThreshold)
         ctx.pendingMemberSearches = name :: ctx.pendingMemberSearches
-      }
       ctx.findMemberCount = recCount + 1
       try go(this)
       catch {
         case ex: Throwable =>
           core.println(s"findMember exception for $this member $name, pre = $pre, recCount = $recCount")
-          throw ex // DEBUG
+          throw new RecursionOverflow("find-member", pre, name, ex)
       }
       finally {
         if (recCount >= Config.LogPendingFindMemberThreshold)
@@ -4546,56 +4541,6 @@ object Types {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = true
   }
 
-  // ----- Exceptions -------------------------------------------------------------
-
-  class TypeError(msg: String) extends Exception(msg)
-
-  class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])
-    extends TypeError(
-      s"malformed type: $pre is not a legal prefix for $denot because it contains abstract type member${if (absMembers.size == 1) "" else "s"} ${absMembers.mkString(", ")}")
-
-  class MissingType(pre: Type, name: Name)(implicit ctx: Context) extends TypeError(
-    i"""cannot resolve reference to type $pre.$name
-       |the classfile defining the type might be missing from the classpath${otherReason(pre)}""") {
-    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 for ${showPrefixSafely(pre)}$name too deep.
-       |searches, from inner to outer: .${ctx.pendingMemberSearches}% .%""")
-
-  private def otherReason(pre: Type)(implicit ctx: Context): String = pre match {
-    case pre: ThisType if pre.cls.givenSelfType.exists =>
-      i"\nor the self type of $pre might not contain all transitive dependencies"
-    case _ => ""
-  }
-
-  class CyclicReference private (val denot: SymDenotation)
-    extends TypeError(s"cyclic reference involving $denot") {
-    def toMessage(implicit ctx: Context) = CyclicReferenceInvolving(denot)
-  }
-
-  object CyclicReference {
-    def apply(denot: SymDenotation)(implicit ctx: Context): CyclicReference = {
-      val ex = new CyclicReference(denot)
-      if (!(ctx.mode is Mode.CheckCyclic)) {
-        cyclicErrors.println(ex.getMessage)
-        for (elem <- ex.getStackTrace take 200)
-          cyclicErrors.println(elem.toString)
-      }
-      ex
-    }
-  }
-
-  class MergeError(msg: String, val tp1: Type, val tp2: Type) extends TypeError(msg)
-
   // ----- Debug ---------------------------------------------------------
 
   @sharable var debugTrace = false

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -14,7 +14,6 @@ import Symbols._
 import NameOps._
 import NameKinds.DefaultGetterName
 import typer.Inliner
-import typer.ErrorReporting.cyclicErrorMsg
 import transform.ValueClasses
 import transform.SymUtils._
 import dotty.tools.io.File
@@ -243,10 +242,10 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
       val ancestorTypes0 =
         try linearizedAncestorTypes(cinfo)
         catch {
-          case ex: CyclicReference =>
+          case ex: TypeError =>
             // See neg/i1750a for an example where a cyclic error can arise.
             // The root cause in this example is an illegal "override" of an inner trait
-            ctx.error(cyclicErrorMsg(ex), csym.pos)
+            ctx.error(ex.toMessage, csym.pos)
             defn.ObjectType :: Nil
         }
       if (ValueClasses.isDerivedValueClass(csym)) {

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

@@ -6,7 +6,6 @@ import Flags._, Symbols._, Contexts._, Types._, Scopes._, Decorators._
 import util.HashSet
 import collection.mutable
 import collection.immutable.BitSet
-import typer.ErrorReporting.cyclicErrorMsg
 import scala.annotation.tailrec
 
 /** A module that can produce a kind of iterator (`Cursor`),
@@ -133,10 +132,10 @@ object OverridingPairs {
             }
           }
           catch {
-            case ex: CyclicReference =>
+            case ex: TypeError =>
               // See neg/i1750a for an example where a cyclic error can arise.
               // The root cause in this example is an illegal "override" of an inner trait
-              ctx.error(cyclicErrorMsg(ex), base.pos)
+              ctx.error(ex.toMessage, base.pos)
           }
         } else {
           curEntry = curEntry.prev

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

@@ -352,18 +352,15 @@ object Checking {
         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
+            !checkNonCyclic(mbr.symbol, bounds, reportErrors = true).isError
           case _ =>
-            false
+            true
         }
       }
       catch {
-        case ex: CyclicFindMember =>
+        case ex: RecursionOverflow =>
           ctx.error(em"cyclic reference involving type $name", pos)
-          true
+          false
       }
   }
 

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

@@ -23,26 +23,6 @@ object ErrorReporting {
     ErrorType(msg)
   }
 
-  def cyclicErrorMsg(ex: CyclicReference)(implicit ctx: Context) = {
-    val cycleSym = ex.denot.symbol
-    def errorMsg(msg: Message, cx: Context): Message =
-      if (cx.mode is Mode.InferringReturnType) {
-        cx.tree match {
-          case tree: untpd.DefDef if !tree.tpt.typeOpt.exists =>
-            OverloadedOrRecursiveMethodNeedsResultType(tree.name)
-          case tree: untpd.ValDef if !tree.tpt.typeOpt.exists =>
-            RecursiveValueNeedsResultType(tree.name)
-          case _ =>
-            errorMsg(msg, cx.outer)
-        }
-      } else msg
-
-    if (cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm)
-      CyclicReferenceInvolvingImplicit(cycleSym)
-    else
-      errorMsg(ex.toMessage, ctx)
-  }
-
   def wrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree], pos: Position)(implicit ctx: Context) =
     errorType(WrongNumberOfTypeArgs(fntpe, expectedArgs, actual)(ctx), pos)
 

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

@@ -1615,7 +1615,7 @@ class RefChecks extends MiniPhase { thisPhase =>
       } catch {
         case ex: TypeError =>
           if (settings.debug) ex.printStackTrace()
-          unit.error(tree.pos, ex.getMessage())
+          unit.error(tree.pos, ex.toMssage)
           tree
       } finally {
         localTyper = savedLocalTyper

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

@@ -1861,8 +1861,7 @@ class Typer extends Namer
       assertPositioned(tree)
       try adapt(typedUnadapted(tree, pt, locked), pt, locked)
       catch {
-        case ex: CyclicReference => errorTree(tree, cyclicErrorMsg(ex))
-        case ex: TypeError => errorTree(tree, ex.getMessage)
+        case ex: TypeError => errorTree(tree, ex.toMessage)
       }
     }
 

tests/neg/i4368.scala

@@ -110,7 +110,7 @@ object Test7 {
 object Test8 {
 
   class A {
-    type T = B#U  // error: cyclic
+    type T = B#U
   }
 
   class B {