Refine criterion when to use fullyDefinedType in ClassTag search

Author: odersky

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

@@ -5116,17 +5116,11 @@ object Types extends TypeUtils {
      */
     private def currentEntry(using Context): Type = ctx.typerState.constraint.entry(origin)
 
-    /** For uninstantiated type variables: the lower bound */
-    def lowerBound(using Context): Type = currentEntry.loBound
-
-    /** For uninstantiated type variables: the upper bound */
-    def upperBound(using Context): Type = currentEntry.hiBound
-
     /** For uninstantiated type variables: Is the lower bound different from Nothing? */
-    def hasLowerBound(using Context): Boolean = !lowerBound.isExactlyNothing
+    def hasLowerBound(using Context): Boolean = !currentEntry.loBound.isExactlyNothing
 
     /** For uninstantiated type variables: Is the upper bound different from Any? */
-    def hasUpperBound(using Context): Boolean = !upperBound.isTopOfSomeKind
+    def hasUpperBound(using Context): Boolean = !currentEntry.hiBound.isTopOfSomeKind
 
     /** Unwrap to instance (if instantiated) or origin (if not), until result
      *  is no longer a TypeVar

compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -20,6 +20,7 @@ import ast.tpd.*
 import Synthesizer.*
 import sbt.ExtractDependencies.*
 import xsbti.api.DependencyContext.*
+import TypeComparer.{fullLowerBound, fullUpperBound}
 
 /** Synthesize terms for special classes */
 class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
@@ -50,18 +51,20 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       	// add that special case.
         def isGroundConstr(tp: Type): Boolean = tp.dealias match
           case tvar: TypeVar if ctx.typerState.constraint.contains(tvar) => false
+          case pref: TypeParamRef if ctx.typerState.constraint.contains(pref) => false
           case tp: AndOrType => isGroundConstr(tp.tp1) && isGroundConstr(tp.tp2)
           case _ => true
         instArg(
             if tvar.hasLowerBound then
-              if isGroundConstr(tvar.lowerBound) then tvar.instantiate(fromBelow = true)
+              if isGroundConstr(fullLowerBound(tvar.origin)) then tvar.instantiate(fromBelow = true)
               else if isFullyDefined(tp, ForceDegree.all) then tp
               else NoType
             else if tvar.hasUpperBound then
-              if isGroundConstr(tvar.upperBound) then tvar.instantiate(fromBelow = false)
+              if isGroundConstr(fullUpperBound(tvar.origin)) then tvar.instantiate(fromBelow = false)
               else if isFullyDefined(tp, ForceDegree.all) then tp
               else NoType
-            else NoType)
+            else
+              NoType)
       case _ =>
         tp
 
@@ -593,9 +596,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
                   resType <:< target
                   val tparams = poly.paramRefs
                   val variances = childClass.typeParams.map(_.paramVarianceSign)
-                  val instanceTypes = tparams.lazyZip(variances).map((tparam, variance) =>
+                  val instanceTypes = tparams.lazyZip(variances).map: (tparam, variance) =>
                     TypeComparer.instanceType(tparam, fromBelow = variance < 0, Widen.Unions)
-                  )
                   val instanceType = resType.substParams(poly, instanceTypes)
                   // this is broken in tests/run/i13332intersection.scala,
                   // because type parameters are not correctly inferred.

tests/pos/i23611a.scala

@@ -0,0 +1,30 @@
+import java.io.{File, IOException}
+import java.net.URI
+import java.nio.file.{Path, Paths}
+import scala.reflect.ClassTag
+
+trait FileConnectors {
+  def listPath(path: => Path): ZStream[Any, IOException, Path]
+
+  final def listFile(file: => File): ZStream[Any, IOException, File] =
+    for {
+      path <- null.asInstanceOf[ZStream[Any, IOException, Path]]
+      r    <- listPath(path).mapZIO(a => ZIO.attempt(a.toFile).refineToOrDie)
+    } yield r
+}
+
+sealed abstract class CanFail[-E]
+object CanFail:
+  given [E]: CanFail[E] = ???
+
+sealed trait ZIO[-R, +E, +A]
+extension [R, E <: Throwable, A](self: ZIO[R, E, A])
+  def refineToOrDie[E1 <: E: ClassTag](using CanFail[E]): ZIO[R, E1, A] = ???
+
+object ZIO:
+  def attempt[A](code: => A): ZIO[Any, Throwable, A] = ???
+
+sealed trait ZStream[-R, +E, +A]:
+  def map[B](f: A => B): ZStream[R, E, B] = ???
+  def flatMap[R1 <: R, E1 >: E, B](f: A => ZStream[R1, E1, B]): ZStream[R1, E1, B]
+  def mapZIO[R1 <: R, E1 >: E, A1](f: A => ZIO[R1, E1, A1]): ZStream[R1, E1, A1]