Check for good bounds before reporting other bounds violations

Fixes #15568

Author: odersky

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

@@ -181,13 +181,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         => Checking.checkAppliedTypesIn(tree)
       case _ =>
 
-    private def checkGoodBounds(tpe: Type, pos: SrcPos)(using Context): Unit = 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)
-      case _ =>
-
     private def removeUnwantedAnnotations(sym: Symbol, metaAnnotSym: Symbol,
         metaAnnotSymBackup: Symbol, keepIfNoRelevantAnnot: Boolean)(using Context): Unit =
       def shouldKeep(annot: Annotation): Boolean =
@@ -352,7 +345,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           for arg <- args do
             checkInferredWellFormed(arg)
-            checkGoodBounds(arg.tpe, arg.srcPos)
+            Checking.checkGoodBounds(arg.tpe, arg.srcPos)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
             Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])

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

@@ -73,10 +73,11 @@ object Checking {
           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),
-          arg.srcPos.focus)
+      if checkGoodBounds(arg.tpe, arg.srcPos.focus) then
+        report.error(
+            showInferred(DoesNotConformToBound(arg.tpe, which, bound),
+                app, tpt),
+            arg.srcPos.focus)
 
   /** Check that type arguments `args` conform to corresponding bounds in `tl`
    *  Note: This does not check the bounds of AppliedTypeTrees. These
@@ -85,6 +86,15 @@ 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
+
   /** Check applied type trees for well-formedness. This means
    *   - all arguments are within their corresponding bounds
    *   - if type is a higher-kinded application with wildcard arguments,

tests/neg/i15568.check

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

tests/neg/i15568.scala

@@ -0,0 +1,3 @@
+trait Foo[X >: Int <: String]
+
+type Bar = Foo[? >: Int <: String] // error