Reject all explicitly written type references with bad bounds

Fixes further unsoundness examples added to neg/i15569.scala.

Author: odersky

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

@@ -281,6 +281,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           super.transform(tree)(using gadtCtx)
         case tree: Ident =>
           if tree.isType then
+            Checking.checkGoodBounds(tree.tpe, tree.srcPos)
             checkNotPackage(tree)
           else
             if tree.symbol.is(Inline) && !Inlines.inInlineMethod then
@@ -295,6 +296,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             ctx.compilationUnit.needsInlining = true
           if name.isTypeName then
             Checking.checkRealizable(qual.tpe, qual.srcPos)
+            Checking.checkGoodBounds(tree.tpe, tree.srcPos)
             withMode(Mode.Type)(super.transform(checkNotPackage(tree)))
           else
             checkNoConstructorProxy(tree)
@@ -345,12 +347,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           for arg <- args do
             checkInferredWellFormed(arg)
-            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.
-              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

@@ -87,12 +87,12 @@ object Checking {
     checkBounds(args, tl.paramInfos, _.substParams(tl, _))
 
   def checkGoodBounds(tpe: Type, pos: SrcPos)(using Context): Boolean =
-    def recur(tp: Type) = tp.dealias match
+    def recur(tp: Type): Boolean = 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)
+        recur(tp.info)
+      case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+        val tpStr = if tp eq tpe then "" else i" $tpe"
+        report.error(i"type$tpStr has potentially conflicting bounds $tp", pos)
         false
       case _ =>
         true

tests/init/neg/i11572.scala

@@ -100,7 +100,7 @@ object Indirect {
   trait U {
     trait X {
       val q: A & B = ???
-      type M = q.L
+      type M = q.L // error: conflicting bounds
     }
     final lazy val p: X = ???
     def brand(x: Any): p.M = x // error: conflicting bounds
@@ -119,7 +119,7 @@ object Indirect2 {
     }
     trait X {
       val q: Y = ???
-      type M = q.r.L
+      type M = q.r.L  // error: conflicting bounds
     }
     final lazy val p: X = ???
     def brand(x: Any): p.M = x // error: conflicting bounds
@@ -152,7 +152,7 @@ object Rec2 {
     }
     trait X {
       val q: Y = ???
-      type M = q.r.L
+      type M = q.r.L // error: conflicting bounds
     }
     final lazy val p: X = ???
     def brand(x: Any): p.M = x // error: conflicting bounds
@@ -171,7 +171,7 @@ object Indirect3 {
     }
     trait X {
       val q: Y = ???
-      type M = q.r.L
+      type M = q.r.L // error: conflicting bounds
     }
     final lazy val p: X = ???
     def brand(x: Any): p.M = x // error: conflicting bounds

tests/init/neg/i5854.scala

@@ -1,5 +1,5 @@
 object Test {
-  def g[B >: String <: Int](x: B): Int = x
+  def g[B >: String <: Int](x: B): Int = x // error
   def main(args: Array[String]): Unit = {
     g("foo") // error: Type argument String' does not conform to upper bound Int
   }

tests/neg-custom-args/fatal-warnings/i13820.scala

@@ -0,0 +1,18 @@
+class A {
+  trait Cov[+X] {
+    def get: X
+  }
+  trait Bounded {
+    type T >: Cov[Int] <: Cov[String]
+  }
+  val t: Bounded = new Bounded {
+    // Note: using this instead of t produces an error (as expected)
+    override type T >: t.T <: t.T  // error: conflicting bounds // error: conflicting bounds
+  }
+
+  val covInt = new Cov[Int] {
+    override def get: Int = 3
+  }
+  val str: String = ((covInt: t.T): Cov[String]).get // error: conflicting bounds, was ClassCastException: class Integer cannot be cast to class String
+
+}

tests/neg-strict/i1050.scala

@@ -0,0 +1,5 @@
+trait Expr { type T }
+
+def foo[A](e: Expr { type T = A }) = e match
+  case e1: Expr { type T <: Int } =>
+    val i: Int = ??? : e1.T // error: unrealizable bounds

tests/neg/bounds.scala

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

tests/neg/i11572.scala

@@ -13,3 +13,18 @@ def andThenSub[A, B, C](f: A <:< B, g: B <:< C): A <:< C =
   val unsound: Any <:< Nothing = andThenSub[Any, t, Nothing](summon, summon) // error
   unsound("hi :)")
 
+@main def Test3 = (None: Option[Foo[?]]) match {
+  case _: Option[Foo[t]] =>
+    val unsound: Nothing = (5 : Any) : t  // error
+    (unsound : Unit => Unit).apply(())
+}
+
+@main def Test4 =
+  type t >: Any <: Nothing
+  val unsound: Nothing = (5 : Any) : t  // error
+  (unsound : Unit => Unit).apply(())
+
+@main def Test5 =
+  type t >: Any <: Nothing
+  val unsound: List[Nothing] = List(5 : Any) : List[t]  // error
+  (unsound.head : Unit => Unit).apply(())

tests/neg/i13820.scala

@@ -0,0 +1,5 @@
+class B {
+  val a: String = (((1: Any): b.A): Nothing): String // error
+  val b: { type A >: Any <: Nothing } = loop()
+  def loop(): Nothing = loop()
+}

tests/neg/i15568.check

@@ -10,9 +10,9 @@ object ListMap {
   def apply[A1, B2](elems: Tuple2[A1, B2]*): Map[A1, B2] = empty[A1,B2].++(elems.iterator)
 }
 
-class Test[A] {
+class Test[A <: AnyRef] {
 
   def f[B >: A <: AnyRef](x: A): AnyRef = (x: B)
-  def g[B >: String <: Int](x: B): Int = x
+  def g[B >: String & Int <: Int](x: B): Int = x
 
 }

tests/neg/i15569.scala

@@ -1,5 +1,5 @@
 trait Expr { type T }
 
-def foo[A](e: Expr { type T = A }) = e match
+def foo[A <: Int](e: Expr { type T = A }) = e match
   case e1: Expr { type T <: Int } =>
-    val i: Int = ??? : e1.T
+    val i: Int = ??? : e1.T