wip

Author: bertlebee

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

@@ -5,11 +5,45 @@ import Contexts._, Symbols._, Types._, Flags._
 import Denotations._, SymDenotations._
 import Names.Name, StdNames.nme
 import ast.untpd
+import scala.util.control.NonFatal
 
 /** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
 object ContextOps:
-
+  case class Implosion(ex: Throwable) extends Exception(ex)
   extension (ctx: Context)
+    /** Crash somewhat gracefully, reporting useful info.*/
+    def implode(message: => Any, ex: Throwable): Nothing = {
+      ex match
+        case NonFatal(Implosion(_)) => throw ex // avoid implosions all the way down, ideally we should avoid catching Implosions in the first place
+        case NonFatal(ex) =>
+          given Context = ctx
+          report.error(
+            s"""|An unhandled exception was thrown in the compiler. Please file a crash
+                |report here: https://github.com/lampepfl/dotty/issues/new/choose
+                |
+                |Exception: ${ex.getClass}
+                |  message: ${ex.getMessage()}
+                |  cause: ${ex.getCause()}
+                |  (truncated) stack trace:
+                |    ${ex.getStackTrace().take(10).mkString("\n    ")}
+                |Sources:
+                |  ${ctx.base.sources.keysIterator.mkString("\n  ")}
+                |Files: 
+                |  ${ctx.base.files.keysIterator.mkString("\n  ")}
+                |Context:
+                |  phase: ${ctx.phase}
+                |  owner: ${ctx.owner}
+                |  unit: ${ctx.compilationUnit}
+                |  mode: ${ctx.mode}
+                |  source: ${ctx.source}:${ctx.tree.sourcePos.line + 1}:${ctx.tree.sourcePos.column + 1}
+                |    ${ctx.tree}
+                |
+                |""".stripMargin,
+                      ctx.tree.sourcePos)
+
+          throw Implosion(ex)
+        case _ => throw ex
+    }
 
     /** Enter symbol into current class, if current class is owner of current context,
     *  or into current scope, if not. Should always be called instead of scope.enter

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

@@ -21,6 +21,8 @@ import typer.ImportInfo.withRootImports
 import ast.{tpd, untpd}
 import scala.annotation.internal.sharable
 import scala.util.control.NonFatal
+import dotty.tools.dotc.core.ContextOps.*
+
 
 object Phases {
 
@@ -323,7 +325,7 @@ object Phases {
         val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit).withRootImports
         try run(using unitCtx)
         catch case ex: Throwable =>
-          println(s"$ex while running $phaseName on $unit")
+          unitCtx.implode(i"$ex while running $phaseName on $unit", ex)
           throw ex
         unitCtx.compilationUnit
       }

compiler/src/dotty/tools/dotc/report.scala

@@ -73,7 +73,7 @@ object report:
     error(msg.toMessage, pos)
 
   def error(msg: => String)(using Context): Unit =
-    error(msg, NoSourcePosition)
+    error(msg, NoSourcePosition) //why default to NoSourcePosition? Surely the caller should be encouraged to at least think about the position and specify NoSourcePosition if no sane position exists
 
   def error(ex: TypeError, pos: SrcPos)(using Context): Unit =
     val fullPos = addInlineds(pos)

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

@@ -34,6 +34,7 @@ import ContextFunctionResults._
 import ExplicitOuter._
 import core.Mode
 import util.Property
+import util.Assert.assert
 import reporting._
 
 class Erasure extends Phase with DenotTransformer {

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

@@ -3,6 +3,7 @@ package typer
 
 import core._
 import Contexts._
+import ContextOps._
 import Types._
 import Symbols._
 import StdNames._
@@ -126,9 +127,11 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
     try super.typedUnadapted(tree, pt, locked)
     catch {
       case NonFatal(ex) =>
-        if ctx.phase != Phases.typerPhase && ctx.phase != Phases.inliningPhase then
-          println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
-        throw ex
+        
+        val message = if ctx.phase != Phases.typerPhase && ctx.phase != Phases.inliningPhase then
+          i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}" 
+          else ""
+        ctx.implode(message, ex)
     }
 
   override def inlineExpansion(mdef: DefDef)(using Context): List[Tree] = mdef :: Nil

compiler/src/dotty/tools/dotc/util/Assertion.scala

@@ -0,0 +1,32 @@
+package dotty.tools.dotc.util
+
+import scala.quoted.*
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.ContextOps.implode
+
+object Assert{
+
+  inline def assert(inline expr: Boolean, inline message: => Any = "")(using inline ctx: Context): Unit =
+    ${ Assert.assertImpl('expr, 'message,  'ctx) }
+
+  def assertImpl(expr: Expr[Boolean], message: Expr[Any], ctx: Expr[Context])(using qctx: Quotes):Expr[Unit] = {
+    import qctx.reflect.*
+    val pos = Position.ofMacroExpansion
+    val position = s"${pos.sourceFile.path}:${pos.startLine + 1}:${pos.startColumn +1}"
+    '{
+      if !$expr then {
+        val expression = ${Expr(expr.asTerm.show(using Printer.TreeAnsiCode))}
+        val pos = ${Expr(position)}
+        val err = AssertionError(
+            s"""failed assertion at $pos
+            |predicate 
+            |  $expression
+            |was false
+            |${$message}"
+            """.stripMargin
+            )
+        ${ctx}.implode(${message}, err)
+      }
+    }
+  }
+}