Scan the tree without a Transformer

Author: TheElectronWill

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

@@ -68,11 +68,17 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
   override def changesMembers: Boolean = true // the phase adds super accessors and synthetic members
 
+  override def run(using Context): Unit =
+    val unit = ctx.compilationUnit
+    if unit.isJava then
+      checkBounds(unit.tpdTree)
+    else
+      super.run
+
   override def transformPhase(using Context): Phase = thisPhase.next
 
   protected def newTransformer(using Context): Transformer =
-    if ctx.compilationUnit.isJava then LimitedChecksTransformer()
-    else PostTyperTransformer()
+    PostTyperTransformer()
 
   val superAcc: SuperAccessors = new SuperAccessors(thisPhase)
   val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase)
@@ -118,32 +124,30 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
         case _ =>
           tree
-
-  class LimitedChecksTransformer extends Transformer {
-    private def checkAppliedTypes(tree: Tree)(using Context): Unit = tree match
-      case tpt: TypeTree =>
-        Checking.checkAppliedTypesIn(tpt)
-      case app: AppliedTypeTree =>
-        Checking.checkAppliedType(app, EmptyTree)
-      case _ =>
-
-    override def transform(tree: Tree)(using Context): Tree =
-      ctx.debuglog(s"LimitedChecksTransformer.transform(${tree.show})")
-      ctx.debuglog(s"  -- $tree")
-      tree match
-        case Select(qual, name) if name.isTypeName =>
-          Checking.checkRealizable(qual.tpe, qual.posd)
-          if name.isTypeName then
-            super.transform(tree)(using ctx.addMode(Mode.Type))
-        case tree: TypeApply =>
-          val TypeApply(fn, args) = normalizeTypeArgs(tree)
-          args.foreach(checkAppliedTypes)
-        case tree: ValOrDefDef =>
-          checkAppliedTypes(tree.tpt)
-        case _ =>
-          super.transform(tree)
-      tree
-  }
+  end normalizeTypeArgs
+
+  /** Scan a tree and check the type bounds. */
+  def checkBounds(tree: Tree)(using Context): Unit = tree match
+    case tpt: TypeTree =>
+      Checking.checkAppliedTypesIn(tpt)
+    case app: AppliedTypeTree =>
+      Checking.checkAppliedType(app, EmptyTree)
+    case tree: TypeApply =>
+      val TypeApply(fn, args) = normalizeTypeArgs(tree)
+      args.foreach(checkBounds)
+    case tree: ValOrDefDef =>
+      checkBounds(tree.tpt)
+    case PackageDef(pid, stats) =>
+      stats.foreach(checkBounds)
+    case TypeDef(name, rhs) =>
+      checkBounds(rhs)
+    case t: Template =>
+      t.parents.foreach(checkBounds)
+      t.body.foreach(checkBounds)
+    case a: Annotated =>
+      checkBounds(a.arg)
+    case _ =>
+      // no need to check this
 
   class PostTyperTransformer extends Transformer {