Run java bound checks just after typer and then discard java compilation units

Author: TheElectronWill

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

@@ -87,11 +87,8 @@ class Pickler extends Phase {
     }
   }
 
-  protected def discardBeforePickler(unit: CompilationUnit)(using Context): Boolean =
-    unit.isJava // stop here for java files
-
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
-    val result = super.runOn(units.filterNot(discardBeforePickler))
+    val result = super.runOn(units)
     if ctx.settings.YtestPickler.value
       testUnpickler(
         using ctx.fresh

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

@@ -68,13 +68,6 @@ 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
-      AppliedTypeChecker().traverse(unit.tpdTree)
-    else
-      super.run
-
   override def transformPhase(using Context): Phase = thisPhase.next
 
   protected def newTransformer(using Context): Transformer =
@@ -92,53 +85,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     // TODO fill in
   }
 
-  private def normalizeTypeArgs(tree: TypeApply)(using Context): TypeApply = tree.tpe match
-    case pt: PolyType => // wait for more arguments coming
-      tree
-    case _ =>
-      def decompose(tree: TypeApply): (Tree, List[Tree]) = tree.fun match
-        case fun: TypeApply =>
-          val (tycon, args) = decompose(fun)
-          (tycon, args ++ tree.args)
-        case _ =>
-          (tree.fun, tree.args)
-      end decompose
-      def reorderArgs(pnames: List[Name], namedArgs: List[NamedArg], otherArgs: List[Tree]): List[Tree] = pnames match
-        case pname :: pnames1 =>
-          namedArgs.partition(_.name == pname) match
-            case (NamedArg(_, arg) :: _, namedArgs1) =>
-              arg :: reorderArgs(pnames1, namedArgs1, otherArgs)
-            case _ =>
-              val otherArg :: otherArgs1 = otherArgs
-              otherArg :: reorderArgs(pnames1, namedArgs, otherArgs1)
-        case nil =>
-          assert(namedArgs.isEmpty && otherArgs.isEmpty)
-          Nil
-      end reorderArgs
-
-      val (tycon, args) = decompose(tree)
-      tycon.tpe.widen match
-        case tp: PolyType if args.exists(isNamedArg) =>
-          val (namedArgs, otherArgs) = args.partition(isNamedArg)
-          val args1 = reorderArgs(tp.paramNames, namedArgs.asInstanceOf[List[NamedArg]], otherArgs)
-          TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
-        case _ =>
-          tree
-  end normalizeTypeArgs
-
-  private class AppliedTypeChecker extends TreeTraverser {
-    /** Scan a tree and check all the AppliedTypeTrees in it. */
-    def traverse(tree: Tree)(using Context): Unit = tree match
-      case tpt: TypeTree =>
-        Checking.checkAppliedTypesIn(tpt)
-      case tree: AppliedTypeTree =>
-        Checking.checkAppliedType(tree, EmptyTree)
-      case tree: TypeApply =>
-        traverseChildren(normalizeTypeArgs(tree))
-      case _ =>
-        traverseChildren(tree)
-  }
-
   class PostTyperTransformer extends Transformer {
 
     private var inJavaAnnot: Boolean = false
@@ -218,21 +164,54 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         => Checking.checkAppliedTypesIn(tree)
       case _ =>
 
-    private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = {
+    private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree =
       val qual = tree.qualifier
-      qual.symbol.moduleClass.denot match {
+      qual.symbol.moduleClass.denot match
         case pkg: PackageClassDenotation =>
           val pobj = pkg.packageObjFor(tree.symbol)
-          if (pobj.exists)
+          if pobj.exists then
             return transformSelect(cpy.Select(tree)(qual.select(pobj).withSpan(qual.span), tree.name), targs)
         case _ =>
-      }
+
       val tree1 = super.transform(tree)
-      constToLiteral(tree1) match {
+      constToLiteral(tree1) match
         case _: Literal => tree1
         case _ => superAcc.transformSelect(tree1, targs)
-      }
-    }
+
+    private def normalizeTypeArgs(tree: TypeApply)(using Context): TypeApply = tree.tpe match
+      case pt: PolyType => // wait for more arguments coming
+        tree
+      case _ =>
+        def decompose(tree: TypeApply): (Tree, List[Tree]) = tree.fun match
+          case fun: TypeApply =>
+            val (tycon, args) = decompose(fun)
+            (tycon, args ++ tree.args)
+          case _ =>
+            (tree.fun, tree.args)
+        end decompose
+
+        def reorderArgs(pnames: List[Name], namedArgs: List[NamedArg], otherArgs: List[Tree]): List[Tree] = pnames match
+          case pname :: pnames1 =>
+            namedArgs.partition(_.name == pname) match
+              case (NamedArg(_, arg) :: _, namedArgs1) =>
+                arg :: reorderArgs(pnames1, namedArgs1, otherArgs)
+              case _ =>
+                val otherArg :: otherArgs1 = otherArgs
+                otherArg :: reorderArgs(pnames1, namedArgs, otherArgs1)
+          case nil =>
+            assert(namedArgs.isEmpty && otherArgs.isEmpty)
+            Nil
+        end reorderArgs
+
+        val (tycon, args) = decompose(tree)
+        tycon.tpe.widen match
+          case tp: PolyType if args.exists(isNamedArg) =>
+            val (namedArgs, otherArgs) = args.partition(isNamedArg)
+            val args1 = reorderArgs(tp.paramNames, namedArgs.asInstanceOf[List[NamedArg]], otherArgs)
+            TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
+          case _ =>
+            tree
+    end normalizeTypeArgs
 
     private object dropInlines extends TreeMap {
       override def transform(tree: Tree)(using Context): Tree = tree match {

compiler/src/dotty/tools/dotc/typer/FrontEnd.scala

@@ -80,6 +80,8 @@ class FrontEnd extends Phase {
         typr.println("typed: " + unit.source)
         record("retained untyped trees", unit.untpdTree.treeSize)
         record("retained typed trees after typer", unit.tpdTree.treeSize)
+        if unit.isJava then
+          JavaChecks.check(unit.tpdTree)
     catch
       case ex: CompilationUnit.SuspendException =>
   }
@@ -92,7 +94,7 @@ class FrontEnd extends Phase {
   }
 
   protected def discardAfterTyper(unit: CompilationUnit)(using Context): Boolean =
-    unit.suspended
+    unit.isJava || unit.suspended
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
     val unitContexts =

compiler/src/dotty/tools/dotc/typer/JavaChecks.scala

@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package typer
+
+import core.Contexts._
+import ast.tpd._
+
+/** PostTyper doesn't run on java sources,
+ *  but some checks still need to be applied.
+ */
+object JavaChecks {
+  /** Check the bounds of AppliedTypeTrees. */
+  private object AppliedTypeChecker extends TreeTraverser {
+    def traverse(tree: Tree)(using Context): Unit = tree match
+      case tpt: TypeTree =>
+        Checking.checkAppliedTypesIn(tpt)
+      case tree: AppliedTypeTree =>
+        Checking.checkAppliedType(tree)
+      case _ =>
+        traverseChildren(tree)
+  }
+
+  /** Scan a tree and check it. */
+  def check(tree: Tree)(using Context): Unit =
+    ctx.debuglog("checking type bounds in " + ctx.compilationUnit.source.name)
+    AppliedTypeChecker.traverse(tree)
+}