Fix calculation to drop transparent classes

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

@@ -557,8 +557,10 @@ trait ConstraintHandling {
   end approximation
 
   private def isTransparent(tp: Type)(using Context): Boolean = tp match
-    case AndType(tp1, tp2) => isTransparent(tp1) && isTransparent(tp2)
-    case _ => tp.typeSymbol.isTransparentClass && !tp.isLambdaSub
+    case AndType(tp1, tp2) =>
+      isTransparent(tp1) && isTransparent(tp2)
+    case _ =>
+      tp.underlyingClassRef(refinementOK = false).typeSymbol.isTransparentClass
 
   /** If `tp` is an intersection such that some operands are transparent trait instances
    *  and others are not, replace as many transparent trait instances as possible with Any
@@ -572,18 +574,17 @@ trait ConstraintHandling {
     var dropped: List[Type] = List() // the types dropped so far, last one on top
 
     def dropOneTransparentClass(tp: Type): Type =
-      val tpd = tp.dealias
-      if isTransparent(tpd) && !kept.contains(tpd) then
-        dropped = tpd :: dropped
+      if isTransparent(tp) && !kept.contains(tp) then
+        dropped = tp :: dropped
         defn.AnyType
-      else tpd match
+      else tp match
         case AndType(tp1, tp2) =>
           val tp1w = dropOneTransparentClass(tp1)
           if tp1w ne tp1 then tp1w & tp2
           else
             val tp2w = dropOneTransparentClass(tp2)
             if tp2w ne tp2 then tp1 & tp2w
-            else tpd
+            else tp
         case _ =>
           tp
 

tests/pos/i16338.scala

@@ -0,0 +1,25 @@
+package de.sciss.kollflitz
+
+import scala.collection.*
+
+type Tagged[U]  = { type Tag  = U }
+type @@ [+T, U] = T with Tagged[U]
+private val anyTagger = new Tagger[Any]
+final class Tagger[U] private[kollflitz] {
+  def apply[T](t : T): T @@ U = t.asInstanceOf[T @@ U]
+}
+def tag[U]: Tagger[U] = anyTagger.asInstanceOf[Tagger[U]]
+
+sealed trait Sorted
+
+
+/** Enrichment methods for random access collections. */
+implicit final class KollFlitzSortedIndexedSeq[A, CC[_], Repr](val self: SeqOps[A, CC, Repr] @@ Sorted)
+  extends AnyVal {
+
+  /** Nearest percentile (rounded index, no interpolation). */
+  def percentile(n: Int): A = self((self.size * n - 50) / 100)
+
+  /** Median found by rounding the index (no interpolation). */
+  def median: A = percentile(50)
+}

tests/pos/i16342.scala

@@ -0,0 +1,18 @@
+type Opaque = Base with Tag
+
+type Base = Any {
+  type Hack
+}
+
+trait Tag
+
+object Opaque {
+  def apply(value: String): Opaque = value.asInstanceOf[Opaque]
+
+  def unapply(userId: Opaque): Option[String] = Option(userId).map(_.value)
+  def unappy2(userId: Base with Tag): Option[String] = Option(userId).map(_.value)
+}
+
+final implicit class Ops(private val userId: Opaque) extends AnyVal {
+  def value: String = userId.asInstanceOf[String]
+}