Fix #10217: Avoid exponential behavior in derivesFrom

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1175,11 +1175,11 @@ class Definitions {
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
 
   def isBottomType(tp: Type): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
+    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.isCombinedRef(NothingClass)
     else isBottomTypeAfterErasure(tp)
 
   def isBottomTypeAfterErasure(tp: Type): Boolean =
-    tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
+    tp.isCombinedRef(NothingClass) || tp.isCombinedRef(NullClass)
 
   /** Is a function class.
    *   - FunctionXXL

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -205,6 +205,12 @@ object Types {
         false
     }
 
+    /** Like isRef, but also extends to unions and intersections */
+    def isCombinedRef(sym: Symbol)(using Context): Boolean = stripped match
+      case AndType(tp1: Type, tp2: Type) => tp1.isRef(sym) || tp2.isRef(sym)
+      case OrType(tp1: Type, tp2: Type) => tp1.isRef(sym) && tp2.isRef(sym)
+      case _ => isRef(sym)
+
     def isAny(using Context): Boolean     = isRef(defn.AnyClass, skipRefined = false)
     def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
     def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
@@ -242,8 +248,8 @@ object Types {
           // If the type is `T | Null` or `T | Nothing`, and `T` derivesFrom the class,
           // then the OrType derivesFrom the class. Otherwise, we need to check both sides
           // derivesFrom the class.
-          if defn.isBottomType(tp.tp1) then loop(tp.tp2)
-          else loop(tp.tp1) && (defn.isBottomType(tp.tp2) || loop(tp.tp2))
+          loop(tp.tp1) && (loop(tp.tp2) || defn.isBottomType(tp.tp2))
+          || defn.isBottomType(tp.tp1) && loop(tp.tp2)
         case tp: JavaArrayType =>
           cls == defn.ObjectClass
         case _ =>
@@ -1533,6 +1539,9 @@ object Types {
     /** Is this (an alias of) the `scala.Null` type? */
     final def isNullType(using Context) = isRef(defn.NullClass)
 
+    /** Is this (an alias of) the `scala.Null` or `scala.Nothing` type? */
+    final def isNullOrNothingType(using Context) = isNullType || isRef(defn.NothingClass)
+
     /** The resultType of a LambdaType, or ExprType, the type itself for others */
     def resultType(using Context): Type = this
 

tests/pos/i10217.scala

@@ -0,0 +1,27 @@
+trait A
+trait B
+trait C
+trait D
+trait E
+trait F
+trait G
+trait H
+trait I
+trait J
+trait K
+trait L
+trait M
+trait N
+trait O
+trait P
+trait Q
+trait R
+trait S
+trait T
+trait U
+trait V
+trait W
+
+class Foo[T]
+
+val f = Foo[A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U]