Error instead of crash when sigName comes up with a missing reference.

A TypeRef can have be unresolved, either because it refers to something that's missing
from the classpath or because of transitive self type references. Instead of crashing
in sigName, we now report the error.

Achieved by defining a new exception type, MissingType, which derives from TypeError.

This catches t7933.scala, now integrated in the neg/selfreq.scala. The problem there was
a reference to AbsSettings, which was not a member of StandardScalaSettings.this,
but was a member of the required type of AbsSettings, which itself appeared in the
required type of StandardScalaSettings. We will outlaw in the next commit such transitive
required references.

Also collapsed TypeError and FatalTypeError. It was a misnomer anyway. Fatal were those
type errors that were caught and reported!

Open: Where else we should check for unresolved NamedTypes.

Author: odersky

src/dotty/tools/dotc/core/TypeErasure.scala

@@ -439,6 +439,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case ErasedValueType(_, underlying) =>
       sigName(underlying)
     case tp: TypeRef =>
+      if (!tp.denot.exists) throw new MissingType(tp.prefix, tp.name)
       val sym = tp.symbol
       if (!sym.isClass) sigName(tp.info)
       else if (isDerivedValueClass(sym)) sigName(eraseDerivedValueClassRef(tp))

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

@@ -936,6 +936,7 @@ object Types {
     /** the self type of the underlying classtype */
     def givenSelfType(implicit ctx: Context): Type = this match {
       case tp @ RefinedType(parent, name) => tp.wrapIfMember(parent.givenSelfType)
+      case tp: ThisType => tp.tref.givenSelfType
       case tp: TypeProxy => tp.underlying.givenSelfType
       case _ => NoType
     }
@@ -3181,14 +3182,23 @@ object Types {
   // ----- Exceptions -------------------------------------------------------------
 
   class TypeError(msg: String) extends Exception(msg)
-  class FatalTypeError(msg: String) extends TypeError(msg)
 
   class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])
-    extends FatalTypeError(
-      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(", ")}""")
+    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)}""".stripMargin)
+
+  private def otherReason(pre: Type)(implicit ctx: Context): String = pre match {
+    case pre: ThisType if pre.givenSelfType.exists =>
+      i"\nor the self type of $pre might not contain all transitive dependencies"
+    case _ => ""
+  }
 
   class CyclicReference private (val denot: SymDenotation)
-    extends FatalTypeError(s"cyclic reference involving $denot") {
+    extends TypeError(s"cyclic reference involving $denot") {
     def show(implicit ctx: Context) = s"cyclic reference involving ${denot.show}"
   }
 
@@ -3204,7 +3214,7 @@ object Types {
     }
   }
 
-  class MergeError(msg: String) extends FatalTypeError(msg)
+  class MergeError(msg: String) extends TypeError(msg)
 
   // ----- Debug ---------------------------------------------------------
 

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

@@ -1087,7 +1087,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     try adapt(typedUnadapted(tree, pt), pt, tree)
     catch {
       case ex: CyclicReference => errorTree(tree, cyclicErrorMsg(ex))
-      case ex: FatalTypeError => errorTree(tree, ex.getMessage)
+      case ex: TypeError => errorTree(tree, ex.getMessage)
     }
   }
 

test/dotc/tests.scala

@@ -139,6 +139,7 @@ class tests extends CompilerTest {
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
+  @Test def neg_selfreq = compileFile(negDir, "selfreq", xerrors = 4)
   @Test def neg_shadowedImplicits = compileFile(negDir, "arrayclone-new", xerrors = 2)
   @Test def neg_traitParamsTyper = compileFile(negDir, "traitParamsTyper", xerrors = 5)
   @Test def neg_traitParamsMixin = compileFile(negDir, "traitParamsMixin", xerrors = 2)

tests/neg/selfreq.scala

@@ -0,0 +1,37 @@
+trait X { self: Y =>
+
+  type T <: self.U
+
+  def foo(x: T): T
+  def foo(x: String): String
+
+}
+
+trait Y { self: Z =>
+
+  type U <: self.V
+
+}
+
+trait Z {
+
+  class V
+
+}
+
+object O {
+  val x: X = ???
+  x.foo("a")
+}
+
+import scala.tools.nsc.interpreter.IMain
+
+object Test extends dotty.runtime.LegacyApp {
+  val engine = new IMain.Factory getScriptEngine()
+  engine.asInstanceOf[IMain].settings.usejavacp.value = true
+  val res2 = engine.asInstanceOf[javax.script.Compilable]
+  res2 compile "8" eval()
+  val res5 = res2 compile """println("hello") ; 8"""
+  res5 eval()
+  res5 eval()
+}