Enhancement: Implement bounds checking

It turns out that bounds checking was missing so far.

Author: odersky

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -11,6 +11,7 @@ import config.{Config, Feature}
 import ast.{tpd, untpd, Trees}
 import Trees.*
 import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents}
+import typer.Checking.{checkBounds, checkAppliedTypesIn}
 import util.{SimpleIdentitySet, EqHashMap, SrcPos}
 import transform.SymUtils.*
 import transform.{Recheck, PreRecheck}
@@ -911,8 +912,27 @@ class CheckCaptures extends Recheck, SymTransformer:
                       |The type needs to be declared explicitly.""", t.srcPos)
               case _ =>
             inferred.foreachPart(checkPure, StopAt.Static)
+        case t @ TypeApply(fun, args) =>
+          fun.knownType.widen match
+            case tl: PolyType =>
+              val normArgs = args.lazyZip(tl.paramInfos).map { (arg, bounds) =>
+                arg.withType(arg.knownType.forceBoxStatus(
+                  bounds.hi.isBoxedCapturing | bounds.lo.isBoxedCapturing))
+              }
+              checkBounds(normArgs, tl)
+            case _ =>
         case _ =>
       }
-
+      if !ctx.reporter.errorsReported then
+        // We dont report errors hre if previous errors were reported, because other
+        // errors often result in bad applied types, but flagging these bad types gives
+        // often worse error messages than the original errors.
+        val checkApplied = new TreeTraverser:
+          def traverse(t: Tree)(using Context) = t match
+            case tree: InferredTypeTree =>
+            case tree: New =>
+            case tree: TypeTree => checkAppliedTypesIn(tree.withKnownType)
+            case _ => traverseChildren(t)
+        checkApplied.traverse(unit)
   end CaptureChecker
 end CheckCaptures

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

@@ -72,7 +72,7 @@ object Recheck:
       val symd = sym.denot
       symd.validFor.firstPhaseId == phase.id + 1 && (sym.originDenotation ne symd)
 
-  extension (tree: Tree)
+  extension [T <: Tree](tree: T)
 
     /** Remember `tpe` as the type of `tree`, which might be different from the
      *  type stored in the tree itself, unless a type was already remembered for `tree`.
@@ -87,11 +87,15 @@ object Recheck:
       if tpe ne tree.tpe then tree.putAttachment(RecheckedType, tpe)
 
     /** The remembered type of the tree, or if none was installed, the original type */
-    def knownType =
+    def knownType: Type =
       tree.attachmentOrElse(RecheckedType, tree.tpe)
 
     def hasRememberedType: Boolean = tree.hasAttachment(RecheckedType)
 
+    def withKnownType(using Context): T = tree.getAttachment(RecheckedType) match
+      case Some(tpe) => tree.withType(tpe).asInstanceOf[T]
+      case None => tree
+
   extension (tpe: Type)
 
     /** Map ExprType => T to () ?=> T (and analogously for pure versions).

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

@@ -67,11 +67,12 @@ object Checking {
    */
   def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds],
     instantiate: (Type, List[Type]) => Type, app: Type = NoType, tpt: Tree = EmptyTree)(using Context): Unit =
-    args.lazyZip(boundss).foreach { (arg, bound) =>
-      if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
-        errorTree(arg,
-          showInferred(MissingTypeParameterInTypeApp(arg.tpe), app, tpt))
-    }
+    if ctx.phase != Phases.checkCapturesPhase then
+      args.lazyZip(boundss).foreach { (arg, bound) =>
+        if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
+          errorTree(arg,
+            showInferred(MissingTypeParameterInTypeApp(arg.tpe), app, tpt))
+      }
     for (arg, which, bound) <- TypeOps.boundsViolations(args, boundss, instantiate, app) do
       report.error(
         showInferred(DoesNotConformToBound(arg.tpe, which, bound), app, tpt),

tests/neg-custom-args/captures/boundschecks.scala

@@ -0,0 +1,18 @@
+object test {
+
+  class Tree
+
+  def f[X <: Tree](x: X): Unit = ()
+
+  class C[X <: Tree](x: X)
+
+  def foo(t: {*} Tree) =
+    f(t) // error
+    f[{*} Tree](t) // error
+    f[Tree](t)  // error
+    val c1 = C(t) // error
+    val c2 = C[{*} Tree](t) // error
+    val c3 = C[Tree](t)  // error
+
+    val foo: C[{*} Tree] = ???
+}

tests/neg-custom-args/captures/boundschecks2.scala

@@ -0,0 +1,13 @@
+object test {
+
+  class Tree
+
+  def f[X <: Tree](x: X): Unit = ()
+
+  class C[X <: Tree](x: X)
+
+  val foo: C[{*} Tree] = ??? // error
+  type T = C[{*} Tree] // error
+  val bar: T -> T = ???
+  val baz: C[{*} Tree] -> Unit = ??? // error
+}