Refine condition when to check and improve error message

Author: odersky

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

@@ -345,7 +345,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           for arg <- args do
             checkInferredWellFormed(arg)
-            if !arg.span.isSynthetic then
+            val isInferred = arg.isInstanceOf[InferredTypeTree] || arg.span.isSynthetic
+            if !isInferred then
               // only check explicit type arguments. We rely on inferred type arguments
               // to either have good bounds (if they come from a constraint), or be derived
               // from values that recursively need to have good bounds.

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

@@ -86,14 +86,17 @@ object Checking {
   def checkBounds(args: List[tpd.Tree], tl: TypeLambda)(using Context): Unit =
     checkBounds(args, tl.paramInfos, _.substParams(tl, _))
 
-  def checkGoodBounds(tpe: Type, pos: SrcPos)(using Context): Boolean = tpe.dealias match
-    case tpe: TypeRef =>
-      checkGoodBounds(tpe.info, pos)
-    case TypeBounds(lo, hi) if !(lo <:< hi) =>
-      report.error(i"type argument has unrealizable bounds $tpe", pos)
-      false
-    case _ =>
-      true
+  def checkGoodBounds(tpe: Type, pos: SrcPos)(using Context): Boolean =
+    def recur(tp: Type) = tp.dealias match
+      case tp: TypeRef =>
+        checkGoodBounds(tp.info, pos)
+      case TypeBounds(lo, hi) if !(lo <:< hi) =>
+        val argStr = if tp eq tpe then "" else i" $tpe"
+        report.error(i"type argument$argStr has potentially unrealizable bounds $tp", pos)
+        false
+      case _ =>
+        true
+    recur(tpe)
 
   /** Check applied type trees for well-formedness. This means
    *   - all arguments are within their corresponding bounds

tests/neg/i15568.check

@@ -1,4 +1,4 @@
 -- Error: tests/neg/i15568.scala:3:15 ----------------------------------------------------------------------------------
 3 |type Bar = Foo[? >: Int <: String] // error
   |               ^
-  |               type argument has unrealizable bounds  >: Int <: String
+  |               type argument has potentially unrealizable bounds  >: Int <: String

tests/neg/tate.scala

@@ -6,6 +6,6 @@
       def coerce[T, U](t: T): U = {
         lazy val bound: Bound[U, _ >: T] = ??? // error: >: T does not conform to upper bound
         def bind = new Bind[U] {}
-        bind.bad(bound, t)  // error: type argument has unrealizable bounds
+        bind.bad(bound, t)
       }
     }