Try to not add a transformer

Author: noti0na1

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1194,6 +1194,10 @@ class TreeUnpickler(reader: TastyReader,
                 res.withAttachment(SuppressedApplyToNone, ())
               else res
 
+      def simplifyLub(tree: Tree): Tree =
+        tree.overwriteType(tree.tpe.simplified)
+        tree
+
       def readLengthTerm(): Tree = {
         val end = readEnd()
         val result =
@@ -1232,34 +1236,37 @@ class TreeUnpickler(reader: TastyReader,
               val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
               Inlined(call, bindings, expansion)
             case IF =>
-              if (nextByte == INLINE) {
-                readByte()
-                InlineIf(readTerm(), readTerm(), readTerm())
-              }
-              else
-                If(readTerm(), readTerm(), readTerm())
+              simplifyLub(
+                if (nextByte == INLINE) {
+                  readByte()
+                  InlineIf(readTerm(), readTerm(), readTerm())
+                }
+                else
+                  If(readTerm(), readTerm(), readTerm()))
             case LAMBDA =>
               val meth = readTerm()
               val tpt = ifBefore(end)(readTpt(), EmptyTree)
               Closure(Nil, meth, tpt)
             case MATCH =>
-              if (nextByte == IMPLICIT) {
-                readByte()
-                InlineMatch(EmptyTree, readCases(end))
-              }
-              else if (nextByte == INLINE) {
-                readByte()
-                InlineMatch(readTerm(), readCases(end))
-              }
-              else Match(readTerm(), readCases(end))
+              simplifyLub(
+                if (nextByte == IMPLICIT) {
+                  readByte()
+                  InlineMatch(EmptyTree, readCases(end))
+                }
+                else if (nextByte == INLINE) {
+                  readByte()
+                  InlineMatch(readTerm(), readCases(end))
+                }
+                else Match(readTerm(), readCases(end)))
             case RETURN =>
               val from = readSymRef()
               val expr = ifBefore(end)(readTerm(), EmptyTree)
               Return(expr, Ident(from.termRef))
             case WHILE =>
               WhileDo(readTerm(), readTerm())
             case TRY =>
-              Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree))
+              simplifyLub(
+                Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree)))
             case SELECTouter =>
               val levels = readNat()
               readTerm().outerSelect(levels, SkolemType(readType()))

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

@@ -12,7 +12,6 @@ import Phases._
 import Symbols._
 import Flags.Module
 import reporting.{ThrowingReporter, Profile}
-import typer.Nullables
 import collection.mutable
 import scala.concurrent.{Future, Await, ExecutionContext}
 import scala.concurrent.duration.Duration
@@ -50,8 +49,6 @@ class Pickler extends Phase {
   private val beforePickling = new mutable.HashMap[ClassSymbol, String]
   private val picklers = new mutable.HashMap[ClassSymbol, TastyPickler]
 
-  private val typeSimplifier = new TypeSimplifyTransformer
-
   /** Drop any elements of this list that are linked module classes of other elements in the list */
   private def dropCompanionModuleClasses(clss: List[ClassSymbol])(using Context): List[ClassSymbol] = {
     val companionModuleClasses =
@@ -69,7 +66,7 @@ class Pickler extends Phase {
     do
       val pickler = new TastyPickler(cls)
       if ctx.settings.YtestPickler.value then
-        beforePickling(cls) = typeSimplifier.transform(tree).show
+        beforePickling(cls) = tree.show
         picklers(cls) = pickler
       val treePkl = new TreePickler(pickler)
       treePkl.pickle(tree :: Nil)
@@ -138,7 +135,7 @@ class Pickler extends Phase {
       }
     pickling.println("************* entered toplevel ***********")
     for ((cls, unpickler) <- unpicklers) {
-      val unpickled = typeSimplifier.transform(unpickler.rootTrees)
+      val unpickled = unpickler.rootTrees
       testSame(i"$unpickled%\n%", beforePickling(cls), cls)
     }
   }
@@ -154,21 +151,4 @@ class Pickler extends Phase {
                    |
                    |  diff before-pickling.txt after-pickling.txt""".stripMargin)
   end testSame
-
-  // Overwrite types of If, Match, and Try nodes with simplified types
-  // to avoid inconsistencies in unsafe nulls
-  class TypeSimplifyTransformer extends TreeMapWithPreciseStatContexts:
-    override def transform(tree: Tree)(using Context): Tree =
-      try tree match
-        case _: If | _: Match | _: Try if Nullables.unsafeNullsEnabled =>
-          val newTree = super.transform(tree)
-          newTree.overwriteType(newTree.tpe.simplified)
-          newTree
-        case _ =>
-          super.transform(tree)
-      catch
-        case ex: TypeError =>
-          report.error(ex, tree.srcPos)
-          tree
-  end TypeSimplifyTransformer
 }

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

@@ -460,6 +460,10 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
+        case _: If | _: Match | _: Try =>
+          val newTree = super.transform(tree)
+          newTree.overwriteType(newTree.tpe.simplified)
+          newTree
         case tree =>
           super.transform(tree)
       }