Run bounds checks on java compilation units

Checking every Select of a java-defined symbol would be too costly and still not perfect.
The implemented compromise is to check bounds during the compilation of .java source files.
To do this, a new JavaChecks file is added and called by FrontEnd.
We can't simply discard java compilation units after PostTyper (instead of after Typer),
because sbt.ExtractDependencies (and maybe others) runs before PostTyper and cannot process java sources.

Author: TheElectronWill

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

@@ -84,6 +84,13 @@ class FrontEnd extends Phase {
       case ex: CompilationUnit.SuspendException =>
   }
 
+  def javaCheck(using Context): Unit = monitor("checking java") {
+    val unit = ctx.compilationUnit
+    if unit.isJava then
+      JavaChecks.check(unit.tpdTree)
+  }
+
+
   private def firstTopLevelDef(trees: List[tpd.Tree])(using Context): Symbol = trees match {
     case PackageDef(_, defs) :: _    => firstTopLevelDef(defs)
     case Import(_, _) :: defs        => firstTopLevelDef(defs)
@@ -113,6 +120,8 @@ class FrontEnd extends Phase {
 
     unitContexts.foreach(typeCheck(using _))
     record("total trees after typer", ast.Trees.ntrees)
+    unitContexts.foreach(javaCheck(using _)) // after typechecking to avoid cycles
+
     val newUnits = unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
     val suspendedUnits = ctx.run.suspendedUnits
     if newUnits.isEmpty && suspendedUnits.nonEmpty && !ctx.reporter.errorsReported then

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 =
+    report.debuglog("checking type bounds in " + ctx.compilationUnit.source.name)
+    AppliedTypeChecker.traverse(tree)
+}

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -229,8 +229,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
      */
     final def checkFile(testSource: TestSource): Option[JFile] = (testSource match {
       case ts: JointCompilationSource =>
-        ts.files.collectFirst { case f if !f.isDirectory => new JFile(f.getPath.replaceFirst("\\.scala$", ".check")) }
-
+        ts.files.collectFirst {
+          case f if !f.isDirectory =>
+            new JFile(f.getPath.replaceFirst("\\.(scala|java)$", ".check"))
+        }
       case ts: SeparateCompilationSource =>
         Option(new JFile(ts.dir.getPath + ".check"))
     }).filter(_.exists)
@@ -679,7 +681,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     def getErrorMapAndExpectedCount(files: Seq[JFile]): (HashMap[String, Integer], Int) = {
       val errorMap = new HashMap[String, Integer]()
       var expectedErrors = 0
-      files.filter(_.getName.endsWith(".scala")).foreach { file =>
+      files.filter(isSourceFile).foreach { file =>
         Using(Source.fromFile(file, "UTF-8")) { source =>
           source.getLines.zipWithIndex.foreach { case (line, lineNbr) =>
             val errors = line.toSeq.sliding("// error".length).count(_.unwrap == "// error")

tests/neg/WrongBounds.java

@@ -0,0 +1,7 @@
+import java.util.*;
+
+class WrongBounds {
+  class LL<T> extends ArrayList<List<T>> {}
+  class Wrap<T extends List<List<?>>> extends ArrayList<T> {}
+  class Wrong<T extends LL<?>> extends Wrap<T> {} // error
+}

tests/neg/java-wrong-bounds/D_1.scala

@@ -0,0 +1,5 @@
+class A
+
+class D[T >: A](v: T) {
+  def getV(): T = v
+}

tests/neg/java-wrong-bounds/J_2.java

@@ -0,0 +1,23 @@
+public class J_2 extends D<String> { // error
+
+  public J_2() {
+    super(null);
+  }
+
+  public static D<String> getDS() { // error
+    return new D<String>("DS");
+  }
+
+  public static final D<String> fieldDS = new D<String>("DS"); // error
+
+  public static void useDS(D<String> ds) {} // error
+
+  public static <A extends D<String>> void genericDS() {} // error
+
+  public static void useOK(D<?> ds) {}
+
+  public static D<?> getOK() {return null;}
+
+  public static <A extends D<?>> D<?> genericOK(A a) {return a;}
+
+}