revert changes to add traces

Author: jtjeferreira

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

@@ -13,8 +13,6 @@ 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. */
@@ -822,7 +820,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       case tp1 =>
         this(tp1)
 
-  private def eraseDerivedValueClass(tp: Type)(using Context): Type = trace.force(i"eraseDerivedValueClass $tp") {
+  private def eraseDerivedValueClass(tp: Type)(using Context): Type = {
     val cls = tp.classSymbol.asClass
     val unbox = valueClassUnbox(cls)
     if unbox.exists then
@@ -832,33 +830,30 @@ 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 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
-      }
+      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
     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.force(i"boxing ${tree.showSummary()}: ${tree.tpe} into $target") {
+    final def box(tree: Tree, target: => String = "")(using Context): Tree = trace(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.force(i"unboxing ${tree.showSummary()}: ${tree.tpe} as a $pt") {
+    def unbox(tree: Tree, pt: Type)(using Context): Tree = trace(i"unboxing ${tree.showSummary()}: ${tree.tpe} as a $pt") {
       pt match {
         case ErasedValueType(tycon, underlying) =>
           def unboxedTree(t: Tree) =