add some traces

Author: jtjeferreira

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

@@ -13,6 +13,8 @@ import transform.ContextFunctionResults.*
 import unpickleScala2.Scala2Erasure
 import Decorators.*
 import Definitions.MaxImplementedFunctionArity
+import dotty.tools.dotc.reporting.trace
+
 import scala.annotation.tailrec
 
 /** The language in which the definition being erased was written. */
@@ -820,7 +822,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       case tp1 =>
         this(tp1)
 
-  private def eraseDerivedValueClass(tp: Type)(using Context): Type = {
+  private def eraseDerivedValueClass(tp: Type)(using Context): Type = trace.force(i"eraseDerivedValueClass $tp") {
     val cls = tp.classSymbol.asClass
     val unbox = valueClassUnbox(cls)
     if unbox.exists then
@@ -830,30 +832,33 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       // The underlying part of an ErasedValueType cannot be an ErasedValueType itself
       val erase = erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, inSigName)
       val erasedUnderlying = erase(underlying)
-      if erasedUnderlying.isInstanceOf[WildcardType] then return WildcardType
-
-      // Ideally, we would just use `erasedUnderlying` as the erasure of `tp`, but to
-      // be binary-compatible with Scala 2 we need two special cases for polymorphic
-      // value classes:
-      // - Given `class Foo[A](x: A) extends AnyVal`, `Foo[X]` should erase like
-      //   `X`, except if its a primitive in which case it erases to the boxed
-      //   version of this primitive.
-      // - Given `class Bar[A](x: Array[A]) extends AnyVal`, `Bar[X]` will be
-      //   erased like `Array[A]` as seen from its definition site, no matter
-      //   the `X` (same if `A` is bounded).
-      //
-      // The binary compatibility is checked by sbt-test/scala2-compat/i8001
-      val erasedValueClass =
-        if erasedUnderlying.isPrimitiveValueType && !genericUnderlying.isPrimitiveValueType then
-          defn.boxedType(erasedUnderlying)
-        else if genericUnderlying.derivesFrom(defn.ArrayClass) then
-          erasure(genericUnderlying)
-        else erasedUnderlying
-
-      if erasedValueClass.exists then ErasedValueType(cls.typeRef, erasedValueClass)
-      else
-        assert(ctx.reporter.errorsReported, i"no erasure for $underlying")
-        NoType
+      if erasedUnderlying.isInstanceOf[WildcardType] then WildcardType
+      else {
+
+        // Ideally, we would just use `erasedUnderlying` as the erasure of `tp`, but to
+        // be binary-compatible with Scala 2 we need two special cases for polymorphic
+        // value classes:
+        // - Given `class Foo[A](x: A) extends AnyVal`, `Foo[X]` should erase like
+        //   `X`, except if its a primitive in which case it erases to the boxed
+        //   version of this primitive.
+        // - Given `class Bar[A](x: Array[A]) extends AnyVal`, `Bar[X]` will be
+        //   erased like `Array[A]` as seen from its definition site, no matter
+        //   the `X` (same if `A` is bounded).
+        //
+        // The binary compatibility is checked by sbt-test/scala2-compat/i8001
+        val erasedValueClass = trace.force(i"erasedValueClass of erasedUnderlying $erasedUnderlying and genericUnderlying $genericUnderlying") {
+          if erasedUnderlying.isPrimitiveValueType && !genericUnderlying.isPrimitiveValueType then
+            defn.boxedType(erasedUnderlying)
+          else if genericUnderlying.derivesFrom(defn.ArrayClass) then
+            erasure(genericUnderlying)
+          else erasedUnderlying
+        }
+
+        if erasedValueClass.exists then ErasedValueType(cls.typeRef, erasedValueClass)
+        else
+          assert(ctx.reporter.errorsReported, i"no erasure for $underlying")
+          NoType
+      }
     else NoType
   }
 

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

@@ -270,7 +270,7 @@ object Erasure {
     def constant(tree: Tree, const: Tree)(using Context): Tree =
       (if (isPureExpr(tree)) const else Block(tree :: Nil, const)).withSpan(tree.span)
 
-    final def box(tree: Tree, target: => String = "")(using Context): Tree = trace(i"boxing ${tree.showSummary()}: ${tree.tpe} into $target") {
+    final def box(tree: Tree, target: => String = "")(using Context): Tree = trace.force(i"boxing ${tree.showSummary()}: ${tree.tpe} into $target") {
       tree.tpe.widen match {
         case ErasedValueType(tycon, _) =>
           New(tycon, cast(tree, underlyingOfValueClass(tycon.symbol.asClass)) :: Nil) // todo: use adaptToType?
@@ -290,7 +290,7 @@ object Erasure {
       }
     }
 
-    def unbox(tree: Tree, pt: Type)(using Context): Tree = trace(i"unboxing ${tree.showSummary()}: ${tree.tpe} as a $pt") {
+    def unbox(tree: Tree, pt: Type)(using Context): Tree = trace.force(i"unboxing ${tree.showSummary()}: ${tree.tpe} as a $pt") {
       pt match {
         case ErasedValueType(tycon, underlying) =>
           def unboxedTree(t: Tree) =