Streamline "assert errors reported" logic

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -88,9 +88,8 @@ object desugar {
             else {
               def msg =
                 s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope.toList}"
-              if (ctx.reporter.errorsReported) ErrorType(msg)
-              else throw new java.lang.Error(msg)
-            }
+			  ErrorType(msg).assertingErrorsReported(msg)
+			}
           case _ =>
             mapOver(tp)
         }

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

@@ -175,8 +175,16 @@ object Decorators {
     recur(enclosingInlineds, pos)
   }
 
-  implicit class reportingDeco[T](val x: T) extends AnyVal {
+  implicit class genericDeco[T](val x: T) extends AnyVal {
     def reporting(op: T => String): T = { println(op(x)); x }
+    def assertingErrorsReported(implicit ctx: Context): T = {
+      assert(ctx.reporter.errorsReported)
+      x
+    }
+    def assertingErrorsReported(msg: => String)(implicit ctx: Context): T = {
+      assert(ctx.reporter.errorsReported, msg)
+      x
+    }
   }
 
   implicit class StringInterpolators(val sc: StringContext) extends AnyVal {

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

@@ -973,7 +973,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2
           case Apply(unapply, `dummyArg` :: Nil) => Nil
           case Inlined(u, _, _) => unapplyImplicits(u)
-          case _ => assert(ctx.reporter.errorsReported); Nil
+          case _ => Nil.assertingErrorsReported
         }
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.pos)

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

@@ -165,10 +165,7 @@ object NamerContextOps {
   private def findModuleBuddy(name: Name, scope: Scope)(implicit ctx: Context) = {
     val it = scope.lookupAll(name).filter(_ is Module)
     if (it.hasNext) it.next()
-    else {
-      assert(ctx.reporter.errorsReported, s"no companion $name in $scope")
-      NoSymbol
-    }
+    else NoSymbol.assertingErrorsReported(s"no companion $name in $scope")
   }
 }
 
@@ -921,8 +918,7 @@ class Namer { typer: Typer =>
                 fullyDefinedType(typedAheadExpr(parent).tpe, "class parent", parent.pos)
               }
             case _ =>
-              assert(ctx.reporter.errorsReported)
-              UnspecifiedErrorType
+              UnspecifiedErrorType.assertingErrorsReported
           }
         }
 
@@ -1036,10 +1032,8 @@ class Namer { typer: Typer =>
    */
   def moduleValSig(sym: Symbol)(implicit ctx: Context): Type = {
     val clsName = sym.name.moduleClassName
-    val cls = ctx.denotNamed(clsName).suchThat(_ is ModuleClass).orElse {
-      assert(ctx.reporter.errorsReported)
-      ctx.newStubSymbol(ctx.owner, clsName)
-    }
+    val cls = ctx.denotNamed(clsName).suchThat(_ is ModuleClass)
+      .orElse(ctx.newStubSymbol(ctx.owner, clsName).assertingErrorsReported)
     ctx.owner.thisType.select(clsName, cls)
   }
 

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

@@ -1448,10 +1448,8 @@ class Typer extends Namer
   }
 
   def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context): Tree = track("typedClassDef") {
-    if (!cls.info.isInstanceOf[ClassInfo]) {
-      assert(ctx.reporter.errorsReported)
-      return cdef.withType(UnspecifiedErrorType)
-    }
+    if (!cls.info.isInstanceOf[ClassInfo]) return EmptyTree.assertingErrorsReported
+
     val TypeDef(name, impl @ Template(constr, parents, self, _)) = cdef
     val superCtx = ctx.superCallContext