Fix #7204: Use evidence based type testing for unapplies

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -71,7 +71,7 @@ trait TreeUtils
           foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr), parents), derived), self), body)
         case Import(expr, _) =>
           foldTree(x, expr)
-        case IsPackageClause(clause @ PackageClause(pid, stats)) =>
+        case clause @ PackageClause(pid, stats) =>
           foldTrees(foldTree(x, pid), stats)(given clause.symbol.localContext)
         case Inferred() => x
         case TypeIdent(_) => x

library/src-bootstrapped/scala/tasty/reflect/TreeUtils.scala

@@ -0,0 +1,39 @@
+package scala.tasty
+package reflect
+/* FIXME Using class tags to type tests abstract type members in unsound
+
+   ```
+   trait R {
+     type Nat
+     type Succ <: Nat
+     type Idx
+     given ClassTag[Nat]
+     given ClassTag[Succ]
+     given ClassTag[Z]
+     def n: Nat
+   }
+   object RI extens R {
+     type Nat = Int
+     type Succ = Int
+     type Idx = Int
+     given ClassTag[Nat] = classOf[Integer]
+     given ClassTag[Succ] = new ClassTag[Integer] {
+       def runtimeClass = classOf[Integer]
+       def unapply(x: Any): Option[Succ] = x match
+         case n: Int if n > 0 => Some(n)
+         case _ => None
+     }
+     given ClassTag[Idx] = classOf[Integer]
+     def n: Nat = 4
+   }
+   val r1: R = RI
+   val r2: R = RI
+   r1.x match {
+     case x: r2.Nat => // Should not match or should have an unchecked waring
+     case x: r1.Idx => // Should not match or should have an unchecked waring
+     case x: r1.Succ => // Should match only if r1.x is an r1.Succ under the constraints set in r1
+   }
+   ```
+*/
+/** Place holder until we implement a ClassTag like abstraction that is sound for all type tests */
+type IsInstanceOf[T] = scala.reflect.ClassTag[T]