Test TypeTestsCasts.foundClasses & handle nesting in AndTypes

Author: dwijnand

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

@@ -154,7 +154,7 @@ object TypeTestsCasts {
       case tp2: RefinedType     => recur(X, tp2.parent) && TypeComparer.hasMatchingMember(tp2.refinedName, X, tp2)
       case tp2: RecType         => recur(X, tp2.parent)
       case _
-      if P.classSymbol.isLocal && foundClasses(X, Nil).exists(P.classSymbol.isInaccessibleChildOf) => // 8
+      if P.classSymbol.isLocal && foundClasses(X).exists(P.classSymbol.isInaccessibleChildOf) => // 8
         false
       case _                    => true
     })
@@ -246,7 +246,7 @@ object TypeTestsCasts {
             if expr.tpe.isBottomType then
               report.warning(TypeTestAlwaysDiverges(expr.tpe, testType), tree.srcPos)
             val nestedCtx = ctx.fresh.setNewTyperState()
-            val foundClsSyms = foundClasses(expr.tpe.widen, Nil)
+            val foundClsSyms = foundClasses(expr.tpe.widen)
             val sensical = checkSensical(foundClsSyms)(using nestedCtx)
             if (!sensical) {
               nestedCtx.typerState.commit()
@@ -267,7 +267,7 @@ object TypeTestsCasts {
         def transformAsInstanceOf(testType: Type): Tree = {
           def testCls = effectiveClass(testType.widen)
           def foundClsSymPrimitive = {
-            val foundClsSyms = foundClasses(expr.tpe.widen, Nil)
+            val foundClsSyms = foundClasses(expr.tpe.widen)
             foundClsSyms.size == 1 && foundClsSyms.head.isPrimitiveValueClass
           }
           if (erasure(expr.tpe) <:< testType)
@@ -373,7 +373,10 @@ object TypeTestsCasts {
     else if tp.isRef(defn.AnyValClass) then defn.AnyClass
     else tp.classSymbol
 
-  private def foundClasses(tp: Type, acc: List[Symbol])(using Context): List[Symbol] = tp.dealias match
-    case OrType(tp1, tp2) => foundClasses(tp2, foundClasses(tp1, acc))
-    case _ => effectiveClass(tp) :: acc
+  private[transform] def foundClasses(tp: Type)(using Context): List[Symbol] =
+    def go(tp: Type, acc: List[Type])(using Context): List[Type] = tp.dealias match
+      case  OrType(tp1, tp2) => go(tp2, go(tp1, acc))
+      case AndType(tp1, tp2) => (for t1 <- go(tp1, Nil); t2 <- go(tp2, Nil); yield AndType(t1, t2)) ::: acc
+      case _                 => tp :: acc
+    go(tp, Nil).map(effectiveClass)
 }

compiler/test/dotty/tools/dotc/transform/TypeTestsCastsTest.scala

@@ -0,0 +1,45 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.*
+import Contexts.*, Decorators.*, Denotations.*, SymDenotations.*, Symbols.*, Types.*
+import Annotations.*
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class TypeTestsCastsTest extends DottyTest:
+  val defn = ctx.definitions; import defn.*
+
+  @Test def orL = checkFound(List(StringType, LongType), OrType(LongType, StringType, false))
+  @Test def orR = checkFound(List(LongType, StringType), OrType(StringType, LongType, false))
+
+  @Test def annot = checkFound(List(StringType, LongType), AnnotatedType(OrType(LongType, StringType, false), Annotation(defn.UncheckedAnnot)))
+
+  @Test def andL = checkFound(List(StringType), AndType(StringType, AnyType))
+  @Test def andR = checkFound(List(StringType), AndType(AnyType, StringType))
+  @Test def andX = checkFound(List(NoType), AndType(StringType, BooleanType))
+
+  // (A | B) & C       => {(A & B), (A & C)}
+  // A & (B | C)       => {(A & B), (A & C)}
+  // (A | B) & (C | D) => {(A & C), (A & D), (B & C), (B & D)}
+  @Test def orInAndL = checkFound(List(StringType, LongType), AndType(OrType(LongType, StringType, false), AnyType))
+  @Test def orInAndR = checkFound(List(StringType, LongType), AndType(AnyType, OrType(LongType, StringType, false)))
+  @Test def orInAndZ =
+    // (Throwable | Exception) & (RuntimeException | Any) =
+    //   Throwable & RuntimeException = RuntimeException
+    //   Throwable & Any              = Throwable
+    //   Exception & RuntimeException = RuntimeException
+    //   Exception & Any              = Exception
+    val ExceptionType = defn.ExceptionClass.typeRef
+    val RuntimeExceptionType = defn.RuntimeExceptionClass.typeRef
+    val tp = AndType(OrType(ThrowableType, ExceptionType, false), OrType(RuntimeExceptionType, AnyType, false))
+    val exp = List(ExceptionType, RuntimeExceptionType, ThrowableType, RuntimeExceptionType)
+    checkFound(exp, tp)
+
+  def checkFound(found: List[Type], tp: Type) =
+    val expected = found.map(_.classSymbol)
+    val obtained = TypeTestsCasts.foundClasses(tp)
+    assertEquals(expected, obtained)
+end TypeTestsCastsTest