fix linenumbers in failed assertion traces

Author: pawelsadlo

utest/src-3/utest/TestBuilder.scala

@@ -29,7 +29,10 @@ object TestBuilder:
     import quotes.reflect._
     val inner =
       if nestedBodyTrees.nonEmpty then Block(setupStats, '{Right(${Expr.ofList(nestedBodyTrees)}.toIndexedSeq)}.asTerm)
-      else Block(setupStats.dropRight(1), '{Left(${setupStats.takeRight(1).head.asInstanceOf[Term].asExpr})}.asTerm)
+      else
+        val term = setupStats.takeRight(1).head.asInstanceOf[Term]
+        val inlinedTerm = Inlined(None,Nil,term) //Inlined results in proper line number generation
+        Block(setupStats.dropRight(1), '{Left(${inlinedTerm.asExpr})}.asTerm)
     '{ TestCallTree(${inner.asExprOf[Either[Any, IndexedSeq[TestCallTree]]]}) }
 
   private def processTest(using Quotes)(test: quotes.reflect.Apply, pathOld: Seq[String], index: Int): (Expr[UTree[String]], Expr[TestCallTree]) =
@@ -66,6 +69,7 @@ object TestBuilder:
 
     def unapply(using Quotes)(tree: quotes.reflect.Tree): Option[(Option[String], quotes.reflect.Tree)] =
       import quotes.reflect._
+      import quotes.reflect.given
 
       Option(tree).collect { case tree: Term => tree.asExpr }.collect {
         // case q"""utest.`package`.*.-($body)""" => (None, body)

utest/src-3/utest/asserts/Tracer.scala

@@ -17,12 +17,27 @@ object Tracer {
     Expr.betaReduce('{ $func($tree)})
   }
 
-  def apply[T](func: Expr[Seq[AssertEntry[T]] => Unit], exprs: Expr[Seq[T]])(using Quotes, Type[T]): Expr[Unit] = {
+
+  //direct call to betareduce provides different context (quotes) in case of Inlined terms,this results in borken linenumbers
+  private def betaReduceKeepLineNumbers(using quotes: Quotes)(tree: quotes.reflect.Term): quotes.reflect.Term = {
     import quotes.reflect._
+    new TreeMap {
+      override def transformTerm(tree: quotes.reflect.Term)(owner: quotes.reflect.Symbol): quotes.reflect.Term = tree match {
+        case Inlined(_, Nil, _) =>
+          super.transformTerm(tree)(owner)
+        case _ =>
+          Term.betaReduce(tree).getOrElse(tree)
+      }
+    }
+      .transformTerm(tree)(Symbol.spliceOwner)
+  }
+
+  def apply[T](func: Expr[Seq[AssertEntry[T]] => Unit], exprs: Expr[Seq[T]])(using Quotes, Type[T]): Expr[Unit] = {
+    import quotes.reflect.*
     exprs match {
       case Varargs(ess) =>
         val trees: Expr[Seq[AssertEntry[T]]] = Expr.ofSeq(ess.map(e => makeAssertEntry(e, codeOf(e))))
-        Expr.betaReduce('{ $func($trees)})
+        betaReduceKeepLineNumbers('{ $func($trees)}.asTerm).asExprOf[Unit]
 
       case _ => throw new RuntimeException(s"Only varargs are supported. Got: ${exprs.asTerm}")
     }

utest/test/src-jvm/test/utest/LineNumbersTests.scala

@@ -0,0 +1,57 @@
+package test.utest
+
+import utest._
+import utest.framework.{TestCallTree, Tree}
+
+object LineNumbersTests extends utest.TestSuite {
+
+  val testsToRun = Tests {
+    test("test1") {
+      val x = 1
+      assert(x == 2)
+    }
+    test("test2") {
+      assert(1 == 2)
+    }
+    test("test3") {
+      test("innerTest3")(assert(1 == 2))
+    }
+    test("test4") {
+      test("innerTest4") {
+        assert(1 == 2)
+      }
+    }
+
+    test("test5") {
+      test("innerTest5") {
+        println("extra statement")
+        assert(1 == 2)
+      }
+    }
+  }
+
+  val testBody = {
+
+    val results = TestRunner.run(
+      testsToRun
+    )
+
+    val stackTraceLinesFromThisFile = results.mapLeaves(_.value.failed.get.getStackTrace.toList.filter(_.getFileName == "LineNumbersTests.scala").toList).leaves.toList
+
+    assert(
+      stackTraceLinesFromThisFile(0).exists(_.getLineNumber == 11),
+      stackTraceLinesFromThisFile(1).exists(_.getLineNumber == 14),
+      stackTraceLinesFromThisFile(2).exists(_.getLineNumber == 17),
+      stackTraceLinesFromThisFile(3).exists(_.getLineNumber == 21),
+      stackTraceLinesFromThisFile(4).exists(_.getLineNumber == 28),
+
+    )
+
+  }
+
+  val tests = Tests(Tree(""), new TestCallTree(Left(testBody))) //don't use Tests macro for stability
+
+}
+
+
+