wip 9

Author: bishabosha

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1184,10 +1184,11 @@ class TreeUnpickler(reader: TastyReader,
               // ================================================================================
 
               // 3 suites passed, 1 failed, 4 total
-              //     tests/pos/avoid.scala failed
+              //     ] failed
               //     tests/pos/i5418.scala failed
               //     tests/pos/i5980.scala failed
-              val srcnme = "???"
+              val srcnmes = Nil//List("i5980", "i5418")
+              val doinspect = srcnmes.exists(ctx.source.name.startsWith)
               var symname = readName()
               var precisesig = readName() match
                 case SignedName(_, sig, _) => sig
@@ -1218,16 +1219,19 @@ class TreeUnpickler(reader: TastyReader,
                       d.atSignature(sig, target).isInstanceOf[MultiDenotation]
                     case _ => false
                   if isAmbiguous then
-                    if ctx.source.name.startsWith(srcnme) then
+                    if doinspect then
                       val diff = if sig != precisesig then i"$sig => $precisesig" else i"$sig"
                       report.error(i"$qual . $name differs ambiguously: [$diff]")
                     makeSelect(qual, name, space.decl(name).atSignature(sig, target).asSeenFrom(pre))
                   else
-                    if ctx.source.name.startsWith(srcnme) && sig != precisesig then
+                    if doinspect && sig != precisesig then
                       report.error(i"$qual . $name differs: [$sig => $precisesig]")
                     select(name, sig, target)
                 case name =>
-                  select(name, Signature.NotAMethod, EmptyTermName)
+                  if doinspect then
+                    report.error(i"$qual . $name nosig")
+                  makeSelect(qual, name, accessibleDenot(qualType, name, Signature.NotAMethod, EmptyTermName))
+                  // select(name, Signature.NotAMethod, EmptyTermName)
               res
             case REPEATED =>
               val elemtpt = readTpt()

tests/pos-tmp/avoid.scala

@@ -0,0 +1,34 @@
+abstract class C {
+  def y: Any
+}
+
+object test {
+  val x = new C{
+    def y: String = "abc"
+  }
+  val z: String = x.y
+}
+
+trait M
+
+// A tricky case involving inner classes, exercised
+// in the large in dotty.tools.dotc.core.NameKinds.scala.
+object Test2 {
+
+  class NK {
+    class I
+    type T
+  }
+
+  val x = new NK { type T = I }
+
+  val y = {
+    class C extends NK { type T = I }
+    new C
+  }
+
+  val z = {
+    class C extends NK { type T = I }
+    new C with M
+  }
+}

tests/pos-tmp/i5418.scala

@@ -0,0 +1,14 @@
+class Test {
+  class Tree[A]
+
+  def fromOrderedKeys[A](xs: Iterator[A]): Tree[A] = ???
+
+  def from[E](it: Iterable[E]): Tree[E] =
+    it match {
+      case r: Range =>
+        val it = r.iterator
+
+        // instantiation of covariant GADTs is unsound
+        fromOrderedKeys(it) // error: type mismatch: found: Iterator[Int](it), required Iterator[E]
+    }
+}

tests/pos-tmp/i5980.scala

@@ -0,0 +1,34 @@
+trait A
+trait B
+
+trait Covariant[F[+_]] {
+  trait G[+X]
+
+  def fx: F[A  &   B] = fy
+  def fy: F[A] & F[B] = fx
+
+  def gx: G[A  &   B] = gy
+  def gy: G[A] & G[B] = gx
+}
+
+trait Contravariant[F[-_]] {
+  trait G[-X]
+
+  def fx: F[A  |   B] = fy
+  def fy: F[A] & F[B] = fx
+
+  def gx: G[A  |   B] = gy
+  def gy: G[A] & G[B] = gx
+}
+
+trait LiskovViolation[F[+_]] {
+  trait A { def children: F[A] }
+  trait B { def children: F[B] }
+  trait C extends A with B { def children: F[A] & F[B] = ??? }
+
+  def fc1: C     = new C {}
+  def fc2: A & B = fc1
+
+  def fy1: F[A & B] = fc1.children
+  def fy2: F[A & B] = fc2.children
+}