Fix #5854: check type annotations for soundness

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -107,7 +107,7 @@ object Summarization {
 
       case Typed(expr, tpt) =>
         if (tpt.tpe.hasAnnotation(defn.UncheckedAnnot)) Summary.empty
-        else analyze(expr)
+        else analyze(expr) ++ effectsOfType(tpt.tpe, tpt)
 
       case NamedArg(name, arg) =>
         analyze(arg)
@@ -201,20 +201,7 @@ object Summarization {
 
       case tdef: TypeDef =>
         if tdef.isClassDef then Summary.empty
-        else {
-          var summary = Summary.empty
-          val tp = tdef.symbol.info
-          val traverser = new TypeTraverser {
-            def traverse(tp: Type): Unit = tp match {
-              case TermRef(_: SingletonType, _) =>
-                summary = summary + analyze(tp, tdef.rhs)
-              case _ =>
-                traverseChildren(tp)
-            }
-          }
-          traverser.traverse(tp)
-          summary
-        }
+        else Summary(effectsOfType(tdef.symbol.info, tdef.rhs))
 
       case _: Import | _: Export =>
         Summary.empty
@@ -227,6 +214,19 @@ object Summarization {
     else summary
   }
 
+  private def effectsOfType(tp: Type, source: Tree)(implicit env: Env): Effects =
+    var summary = Summary.empty
+    val traverser = new TypeTraverser {
+      def traverse(tp: Type): Unit = tp match {
+        case TermRef(_: SingletonType, _) =>
+          summary = summary + analyze(tp, source)
+        case _ =>
+          traverseChildren(tp)
+      }
+    }
+    traverser.traverse(tp)
+    summary.effs
+
   def analyze(tp: Type, source: Tree)(implicit env: Env): Summary =
   trace("summarizing " + tp.show, init, s => s.asInstanceOf[Summary].show) {
     val summary: Summary = tp match {

tests/init/neg/i5854.scala

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

tests/init/neg/paramForwarding.scala.bak

@@ -0,0 +1,89 @@
+// A contains a field A.theValue$$local accessible using the
+// generated getter A.theValue()
+class A(val theValue: Int) {
+  val theValueInA = theValue // use the constructor parameter theValue
+
+  def getTheValue = theValue // virtual call to the getter theValue()
+}
+
+// B contains a field B.theValue$$local accessible using the getter
+// B.theValue() which overrides A.theValue()
+class B(override val theValue: Int) extends A(42) {
+  val theValueInB = theValue
+}
+
+// Bz contains a field Bz.theValue$$local accessible using the getter
+// Bz.theValue() which overrides A.theValue()
+class Bz extends A(42) {
+  override val theValue: Int = 10
+  val theValueInBz = theValue
+}
+
+// C does not contain a field C.theValue$$local, it contains
+// a getter C.theValue() which only calls super.theValue()
+class C(override val theValue: Int) extends A(theValue)
+
+// D contains a field D.other$$local and a corresponding getter.
+class D(val other: Int) extends A(other)
+
+
+// NonVal does not contain a field NonVal.theValue$$local.
+class NonVal(theValue: Int) extends A(theValue) {
+  def getTheValueInNonVal = theValue // use the constructor parameter theValue
+}
+
+// X contains a field X.theValue$$local accessible using the getter
+// X.theValue() which overrides A.theValue()
+class X(override val theValue: Int) extends NonVal(0)
+
+// Y does not contain a field Y.theValue$$local, it contains
+// a getter Y.theValue() which only calls super.theValue()
+class Y(override val theValue: Int) extends NonVal(theValue)
+
+
+object Test {
+  def printFields(obj: Any) =
+    println(obj.getClass.getDeclaredFields.map(_.toString).sorted.toList.mkString("\n"))
+
+  def main(args: Array[String]): Unit = {
+    val b10 = new B(10)
+    val bz = new Bz
+    val c11 = new C(11)
+    val d12 = new D(12)
+    val nv13 = new NonVal(13)
+    val x14 = new X(14)
+    val y15 = new Y(15)
+
+    println("B:")
+    printFields(b10)
+    println("Bz:")
+    printFields(bz)
+    println("C:")
+    printFields(c11)
+    println("D:")
+    printFields(d12)
+    println("NonVal:")
+    printFields(nv13)
+    println("X:")
+    printFields(x14)
+    println("Y:")
+    printFields(y15)
+
+
+    assert(b10.getTheValue == 10)
+    assert(b10.theValue == 10)
+    assert(b10.theValueInB == 10)
+    assert(b10.theValueInA == 42)
+
+    assert(bz.getTheValue == 10)
+    assert(bz.theValue == 10)
+    assert(bz.theValueInBz == 10)
+    assert(bz.theValueInA == 42)
+
+
+    assert(x14.theValue == 14)
+    assert(x14.getTheValue == 14)
+    assert(x14.getTheValueInNonVal == 0)
+    assert(x14.theValueInA == 0)
+  }
+}

tests/init/neg/sep-child-parent.check

@@ -0,0 +1,24 @@
+object bar {
+  trait Sub {
+    type M
+    type L <: M
+    type U >: M
+    type M2 >: L <: U
+  }
+  class Box[V](val v: V)
+
+  class Caster[LL, UU] {
+    trait S2 {
+      type L = LL
+      type U = UU
+    }
+    final lazy val nothing: Nothing = nothing
+    final lazy val sub: S2 & Sub = nothing
+    final lazy val box : Box[S2 & Sub] = new Box(nothing)
+    def upcast(t: box.v.M2): box.v.M2 = t  // error // error
+  }
+  def main(args : Array[String]) : Unit = {
+    val zero : String = (new Caster[Int,String]()).upcast(0)
+    println("...")
+  }
+}