Make TypeErrors sticky

The purpose of this change is that we should always report a thrown TypeError
and not hide it by backtracking into some other alternative.

Wihthout this change test i4564.scala fails after applying the creator applications
commit, since some errors about recursive methods lacking a result type are hidden
by using a constructor instead. Ehere is an example:
```
object NoClashNoSig {
  private def apply(x: Boolean) = if (x) NoClashNoSig(1) else ???   // error: overloaded method apply needs result type
}

case class NoClashNoSig private(x: Int)
```
With introduction of creator applications, `NoClashSig` in `apply` would call the constructor,
effectively hiding the "overloaded method apply needs result type" error. This is not what
we want.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -95,18 +95,19 @@ trait Reporting { this: Context =>
   def strictWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit = {
     val fullPos = addInlineds(pos)
     if (this.settings.strict.value) error(msg, fullPos)
-    else reportWarning(new ExtendMessage(() => msg)(_ + "\n(This would be an error under strict mode)").warning(fullPos))
+    else reportWarning(
+      new ExtendMessage(() => msg)(_ + "\n(This would be an error under strict mode)")
+        .warning(fullPos))
   }
 
-  def error(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit = {
-    reporter.report(new Error(msg, addInlineds(pos)))
-  }
-
-  def errorOrMigrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit = {
+  def error(msg: => Message, pos: SourcePosition = NoSourcePosition, sticky: Boolean = false): Unit = {
     val fullPos = addInlineds(pos)
-    if (ctx.scala2Mode) migrationWarning(msg, fullPos) else error(msg, fullPos)
+    reporter.report(if (sticky) new StickyError(msg, fullPos) else new Error(msg, fullPos))
   }
 
+  def errorOrMigrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    if (ctx.scala2Mode) migrationWarning(msg, pos) else error(msg, pos)
+
   def restrictionError(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report {
       new ExtendMessage(() => msg)(m => s"Implementation restriction: $m").error(addInlineds(pos))
@@ -203,6 +204,9 @@ abstract class Reporter extends interfaces.ReporterResult {
   /** All errors reported by this reporter (ignoring outer reporters) */
   def allErrors: List[Error] = errors
 
+  /** Were sticky errors reported? Overridden in StoreReporter. */
+  def hasStickyErrors: Boolean = false
+
   /** Have errors been reported by this reporter, or in the
    *  case where this is a StoreReporter, by an outer reporter?
    */

compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -31,6 +31,9 @@ class StoreReporter(outer: Reporter) extends Reporter {
   override def hasUnreportedErrors: Boolean =
     outer != null && infos != null && infos.exists(_.isInstanceOf[Error])
 
+  override def hasStickyErrors: Boolean =
+    infos != null && infos.exists(_.isInstanceOf[StickyError])
+
   override def removeBufferedMessages(implicit ctx: Context): List[MessageContainer] =
     if (infos != null) try infos.toList finally infos = null
     else Nil

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -35,6 +35,15 @@ object messages {
     pos: SourcePosition
   ) extends MessageContainer(msgFn, pos, ERROR)
 
+  /** A sticky error is an error that should not be hidden by backtracking and
+   *  trying some alternative path. Typcially, errors issued after catching
+   *  a TypeError exception are sticky.
+   */
+  class StickyError(
+    msgFn: => Message,
+    pos: SourcePosition
+  ) extends Error(msgFn, pos)
+
   class Warning(
     msgFn: => Message,
     pos: SourcePosition

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

@@ -249,7 +249,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
           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(ex.toMessage, csym.sourcePos)
+            ctx.error(ex.toMessage, csym.sourcePos, sticky = true)
             defn.ObjectType :: Nil
         }
       if (ValueClasses.isDerivedValueClass(csym)) {

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

@@ -64,7 +64,7 @@ abstract class MacroTransform extends Phase {
         }
       catch {
         case ex: TypeError =>
-          ctx.error(ex.toMessage, tree.sourcePos)
+          ctx.error(ex.toMessage, tree.sourcePos, sticky = true)
           tree
       }
 

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

@@ -205,7 +205,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
         }
       catch {
         case ex: TypeError =>
-          ctx.error(ex.toMessage, tree.sourcePos)
+          ctx.error(ex.toMessage, tree.sourcePos, sticky = true)
           tree
       }
     if (tree.isInstanceOf[NameTree]) goNamed(tree, start) else goUnnamed(tree, start)

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

@@ -134,7 +134,7 @@ object OverridingPairs {
             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(ex.toMessage, base.sourcePos)
+              ctx.error(ex.toMessage, base.sourcePos, sticky = true)
           }
         } else {
           curEntry = curEntry.prev

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

@@ -16,14 +16,14 @@ object ErrorReporting {
 
   import tpd._
 
-  def errorTree(tree: untpd.Tree, msg: => Message, pos: SourcePosition)(implicit ctx: Context): tpd.Tree =
-    tree.withType(errorType(msg, pos))
+  def errorTree(tree: untpd.Tree, msg: => Message, pos: SourcePosition, sticky: Boolean = false)(implicit ctx: Context): tpd.Tree =
+    tree.withType(errorType(msg, pos, sticky))
 
   def errorTree(tree: untpd.Tree, msg: => Message)(implicit ctx: Context): tpd.Tree =
     errorTree(tree, msg, tree.sourcePos)
 
-  def errorType(msg: => Message, pos: SourcePosition)(implicit ctx: Context): ErrorType = {
-    ctx.error(msg, pos)
+  def errorType(msg: => Message, pos: SourcePosition, sticky: Boolean = false)(implicit ctx: Context): ErrorType = {
+    ctx.error(msg, pos, sticky)
     ErrorType(msg)
   }
 

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

@@ -987,7 +987,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     tree
   } catch {
     case ex: TypeError =>
-      ctx.error(ex.toMessage, tree.sourcePos)
+      ctx.error(ex.toMessage, tree.sourcePos, sticky = true)
       tree
   }
 

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

@@ -2113,7 +2113,7 @@ class Typer extends Namer
         try adapt(typedUnadapted(tree, pt, locked), pt, locked)
         catch {
           case ex: TypeError =>
-            errorTree(tree, ex.toMessage, tree.sourcePos.focus)
+            errorTree(tree, ex.toMessage, tree.sourcePos.focus, sticky = true)
             // This uses tree.span.focus instead of the default tree.span, because:
             // - since tree can be a top-level definition, tree.span can point to the whole definition
             // - that would in turn hide all other type errors inside tree.
@@ -2203,7 +2203,7 @@ class Typer extends Namer
   def tryEither[T](op: Context => T)(fallBack: (T, TyperState) => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setNewTyperState()
     val result = op(nestedCtx)
-    if (nestedCtx.reporter.hasErrors) {
+    if (nestedCtx.reporter.hasErrors && !nestedCtx.reporter.hasStickyErrors)
       record("tryEither.fallBack")
       fallBack(result, nestedCtx.typerState)
     }
@@ -2828,7 +2828,7 @@ class Typer extends Namer
               }
             }
             catch {
-              case ex: TypeError => errorTree(tree, ex.toMessage, tree.sourcePos)
+              case ex: TypeError => errorTree(tree, ex.toMessage, tree.sourcePos, sticky = true)
             }
           val nestedCtx = ctx.fresh.setNewTyperState()
           val app = tryExtension(nestedCtx)