Remove unnecessary call to print

Author: hamzaremmal

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

@@ -418,35 +418,30 @@ object TreeChecker {
     }
 
     override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
-      try
-        val res = tree match
-          case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[?] =>
-            super.typedUnadapted(tree, pt, locked)
-          case _ if tree.isType =>
-            promote(tree)
-          case _ =>
-            val tree1 = super.typedUnadapted(tree, pt, locked)
-            def isSubType(tp1: Type, tp2: Type) =
-              (tp1 eq tp2) || // accept NoType / NoType
-              (tp1 <:< tp2)
-            def divergenceMsg(tp1: Type, tp2: Type) =
-              s"""Types differ
-                |Original type : ${tree.typeOpt.show}
-                |After checking: ${tree1.tpe.show}
-                |Original tree : ${tree.show}
-                |After checking: ${tree1.show}
-                |Why different :
-              """.stripMargin + core.TypeComparer.explained(_.isSubType(tp1, tp2))
-            if (tree.hasType) // it might not be typed because Typer sometimes constructs new untyped trees and resubmits them to typedUnadapted
-              assert(isSubType(tree1.tpe, tree.typeOpt), divergenceMsg(tree1.tpe, tree.typeOpt))
-            tree1
-        checkNoOrphans(res.tpe)
-        phasesToCheck.foreach(_.checkPostCondition(res))
-        res
-      catch case NonFatal(ex) if !ctx.run.enrichedErrorMessage =>
-        val treeStr = tree.show(using ctx.withPhase(ctx.phase.prev.megaPhase))
-        println(ctx.run.enrichErrorMessage(s"exception while retyping $treeStr of class ${tree.className} # ${tree.uniqueId}"))
-        throw ex
+      val res = tree match
+        case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[?] =>
+          super.typedUnadapted(tree, pt, locked)
+        case _ if tree.isType =>
+          promote(tree)
+        case _ =>
+          val tree1 = super.typedUnadapted(tree, pt, locked)
+          def isSubType(tp1: Type, tp2: Type) =
+            (tp1 eq tp2) || // accept NoType / NoType
+            (tp1 <:< tp2)
+          def divergenceMsg(tp1: Type, tp2: Type) =
+            s"""Types differ
+              |Original type : ${tree.typeOpt.show}
+              |After checking: ${tree1.tpe.show}
+              |Original tree : ${tree.show}
+              |After checking: ${tree1.show}
+              |Why different :
+            """.stripMargin + core.TypeComparer.explained(_.isSubType(tp1, tp2))
+          if (tree.hasType) // it might not be typed because Typer sometimes constructs new untyped trees and resubmits them to typedUnadapted
+            assert(isSubType(tree1.tpe, tree.typeOpt), divergenceMsg(tree1.tpe, tree.typeOpt))
+          tree1
+      checkNoOrphans(res.tpe)
+      phasesToCheck.foreach(_.checkPostCondition(res))
+      res
     }
 
     def checkNotRepeated(tree: Tree)(using Context): tree.type = {
@@ -844,7 +839,7 @@ object TreeChecker {
       // We want make sure that transparent inline macros are checked in the same way that
       // non transparent macros are, so we try to prepare a context which would make
       // the checks behave the same way for both types of macros.
-      // 
+      //
       // E.g. Different instances of skolem types are by definition not able to be a subtype of
       // one another, however in practice this is only upheld during typer phase, and we do not want
       // it to be upheld during this check.