Better types for class type parameters

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

@@ -1120,7 +1120,12 @@ object Denotations {
       then this
       else if symbol.isAllOf(ClassTypeParam) then
         val arg = symbol.typeRef.argForParam(pre, widenAbstract = true)
-        if arg.exists then derivedSingleDenotation(symbol, arg.bounds, pre)
+        if arg.exists then
+          val newBounds =
+            if symbol.isCompleted && !symbol.info.containsLazyRefs
+            then symbol.info.bounds & arg.bounds
+            else arg.bounds
+          derivedSingleDenotation(symbol, newBounds, pre)
         else derived(symbol.info)
       else derived(symbol.info)
     }

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

@@ -442,6 +442,14 @@ object Types {
     final def containsWildcardTypes(using Context) =
       existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false)
 
+    /** Does this type contain LazyRef types? */
+    final def containsLazyRefs(using Context) =
+      val acc = new TypeAccumulator[Boolean]:
+        def apply(x: Boolean, tp: Type): Boolean = tp match
+          case _: LazyRef => true
+          case _ => x || foldOver(x, tp)
+      acc(false, this)
+
 // ----- Higher-order combinators -----------------------------------
 
     /** Returns true if there is a part of this type that satisfies predicate `p`.

tests/pos/i15940.scala

@@ -0,0 +1,19 @@
+object Ops:
+  implicit class EitherSeqOps[E, T](private val seq: Seq[Either[E, T]]) extends AnyVal:
+    def sequence: Either[::[E], Seq[T]] = ???
+
+trait BuildException
+case class CompositeBuildException(ex: ::[BuildException]) extends BuildException
+
+trait ActionableDiagnostic
+trait ActionableHandler[A <: ActionableDiagnostic]:
+  def exec: Either[BuildException, Seq[A]]
+
+import Ops._
+
+val test: Either[BuildException, Seq[ActionableDiagnostic]] =
+  // Can be replaced with Seq[Either[BuildException, Seq[ _ <: ActionableDiagnostic]]] , but current version matches better type of missing implicit
+  Seq.empty[ActionableHandler[_]].map(_.exec)
+    .sequence
+    .left.map(_.head)
+    .map(_.flatten) // error