checking composed aliases/classes arguments

Author: soronpo

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

@@ -4534,22 +4534,24 @@ object Types {
     private var preciseSubstitute: Boolean = false
     private var cachedPrecise: Option[Boolean] = None
     protected[Types] def setPreciseSubstitute(p: Boolean): Unit = preciseSubstitute = p
+    private def isPreciseRecur(tp: Type, boringPrecise: Boolean)(using Context): Option[Boolean] = tp match
+      case p: TypeParamRef if p == this => Some(boringPrecise)
+      case at@AppliedType(_, args) =>
+        args
+          .lazyZip(at.tyconTypeParams.view.map(p => p.paramPrecise || boringPrecise)).view
+          .map(isPreciseRecur).collectFirst {
+            case Some(res) => res
+          }
+      case _ => None
+
     override def isPrecise(using Context): Boolean =
       // the param is substituting a precise type or...
       preciseSubstitute || cachedPrecise.getOrElse {
         val precise =
           // the param itself is annotated as precise or the param is first introduced
           // in a precise position of an applied type argument
-          binder.paramPrecises(paramNum) || binder.resType.paramInfoss.view.flatten.flatMap {
-            case p: TypeParamRef if p == this => Some(false)
-            case at @ AppliedType(_, args) =>
-              val paramIdx = args.indexOf(this)
-              val syms = at.tyconTypeParams
-              if syms.isEmpty then None
-              else if paramIdx >= 0 then Some(syms(paramIdx).paramPrecise)
-              else None
-            case _ => None
-          }.headOption.getOrElse(false)
+          binder.paramPrecises(paramNum) ||
+            binder.resType.paramInfoss.view.flatten.flatMap(isPreciseRecur(_, false)).headOption.getOrElse(false)
         cachedPrecise = Some(precise)
         precise
       } ||

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

@@ -12,6 +12,7 @@ object PreciseChecker:
   def check(tparams: List[tpd.TypeDef], applied: Type, mode : Mode)(using Context): Unit =
     applied match
       case tpe@AppliedType(_, args) =>
+        args.foreach(check(tparams, _, mode)) //recursively checking applied params
         val appliedParamPreciseList = tpe.tyconTypeParams.map(_.paramPrecise)
         val tdefParamPreciseMap = tparams.view.map(p => (p.name, p.symbol.paramPrecise)).toMap
 

tests/neg/precise-alias-extends.check

@@ -34,19 +34,27 @@
 48 |  type FooConAlias[-A] = FooCon[A] // error
    |                   ^^
    |            imprecise type parameter A occurs in precise position in preciseTypeAliasExtendLessPrecise.FooCon[A]
--- Error: tests/neg/precise-alias-extends.scala:58:16 ------------------------------------------------------------------
-58 |      type Less[T] <: PBox[T] // error
+-- Error: tests/neg/precise-alias-extends.scala:55:17 ------------------------------------------------------------------
+55 |  type FooAlias1[A] = Box[Foo[A]] // error
+   |                 ^
+   |                 imprecise type parameter A occurs in precise position in preciseTypeAliasComposition.Foo[A]
+-- Error: tests/neg/precise-alias-extends.scala:59:26 ------------------------------------------------------------------
+59 |  type BoxAlias2[@precise A] = Foo[Box[A]] // error
+   |                 ^^^^^^^^^^
+   |                 precise type parameter A occurs in imprecise position in preciseTypeAliasComposition.Box[A]
+-- Error: tests/neg/precise-alias-extends.scala:69:16 ------------------------------------------------------------------
+69 |      type Less[T] <: PBox[T] // error
    |                ^
    |                imprecise type parameter T occurs in precise position in preciseTypeBounds.PBox[T]
--- Error: tests/neg/precise-alias-extends.scala:63:25 ------------------------------------------------------------------
-63 |      type More[@precise T] >: Box[T] // error
+-- Error: tests/neg/precise-alias-extends.scala:74:25 ------------------------------------------------------------------
+74 |      type More[@precise T] >: Box[T] // error
    |                ^^^^^^^^^^
    |                precise type parameter T occurs in imprecise position in preciseTypeBounds.Box[T]
--- Error: tests/neg/precise-alias-extends.scala:67:21 ------------------------------------------------------------------
-67 |    opaque type Less[T] <: PBox[T] = PBox[T] // error
+-- Error: tests/neg/precise-alias-extends.scala:78:21 ------------------------------------------------------------------
+78 |    opaque type Less[T] <: PBox[T] = PBox[T] // error
    |                     ^
    |                     imprecise type parameter T occurs in precise position in preciseTypeBounds.PBox[T]
--- Error: tests/neg/precise-alias-extends.scala:68:30 ------------------------------------------------------------------
-68 |    opaque type More[@precise T] <: Box[T] = Box[T] // error
+-- Error: tests/neg/precise-alias-extends.scala:79:30 ------------------------------------------------------------------
+79 |    opaque type More[@precise T] <: Box[T] = Box[T] // error
    |                     ^^^^^^^^^^
    |                     precise type parameter T occurs in imprecise position in preciseTypeBounds.Box[T]

tests/neg/precise-alias-extends.scala

@@ -48,6 +48,17 @@ object preciseTypeAliasExtendLessPrecise:
   type FooConAlias[-A] = FooCon[A] // error
 
 
+object preciseTypeAliasComposition:
+  trait Foo[@precise T]
+  trait Box[T]
+
+  type FooAlias1[A] = Box[Foo[A]] // error
+  type FooAlias2[A] = Foo[Box[A]]
+
+  type BoxAlias1[@precise A] = Box[Foo[A]]
+  type BoxAlias2[@precise A] = Foo[Box[A]] // error
+
+
 object preciseTypeBounds:
   class Box[T]
   class PBox[@precise T]

tests/neg/precise-typecheck.scala

@@ -25,13 +25,13 @@ object preciseDefs:
   final val list1hi = id(1 :: "hi" :: Nil)
   val list1hiTest: List[1 | "hi"] = list1hi
 
-  val c : Boolean = ???
+  val c: Boolean = ???
   val ifVal = idBox(if c then 2 else 3)
   val ifValTest: Box[2 | 3] = ifVal
 
   def huge[@precise T1, T2, T3, @precise T4, @precise T5](
-    t1: T1, t2 : T2, r : Int
-  )(t3: T3, r2: Int, t4: T4)(t5 : T5*): Box[(T1, T2, T3, T4, T5)] = ???
+    t1: T1, t2: T2, r: Int
+  )(t3: T3, r2: Int, t4: T4)(t5: T5*): Box[(T1, T2, T3, T4, T5)] = ???
 
   val h1 = huge((1, 2), (3, 4), 5)((6, 7), 8, (9, 10))(11, 12)
   val h1Test: Box[((1, 2), (Int, Int), (Int, Int), (9, 10), 11 | 12)] = h1
@@ -44,11 +44,11 @@ object preciseUpperBound:
 
 
 object preciseDepArgs:
-  def same[@precise T](x: T, y: T) : Box[T] = ???
+  def same[@precise T](x: T, y: T): Box[T] = ???
   final val sameVal = same(1, 2)
   val sameValTest: Box[1 | 2] = sameVal
 
-  def sameVarArgs[@precise T](a: T*) : Box[T] = ???
+  def sameVarArgs[@precise T](a: T*): Box[T] = ???
   final val sameVal123hi = sameVarArgs(1, 2, 3, "hi")
   val sameVal123hiTest: Box[1 | 2 | 3 | "hi"] = sameVal123hi
 
@@ -67,7 +67,7 @@ object preciseDepArgs:
 
 
 object preciseExtendClassArgs:
-  class Foo[@precise T](val value : T)
+  class Foo[@precise T](val value: T)
 
   object Bar extends Foo(5)
   val barTest: 5 = Bar.value
@@ -77,7 +77,7 @@ object preciseExtendClassArgs:
 
 
 object preciseEnums:
-  enum Foo[@precise T](val value : T):
+  enum Foo[@precise T](val value: T):
     case Bar extends Foo(5)
     case Baz extends Foo((1, 2))
 
@@ -105,10 +105,10 @@ object preciseDefaultValues:
 
 
 object preciseGivens:
-  given one : 1 = 1
-  def fetch[@precise T <: Int](using T) : Box[T] = ???
+  given one: 1 = 1
+  def fetch[@precise T <: Int](using T): Box[T] = ???
   val f = fetch
-  val fTest : Box[1] = f
+  val fTest: Box[1] = f
 
   class PreciseBox[@precise T]
   given [T]: PreciseBox[T] with {}
@@ -117,7 +117,7 @@ object preciseGivens:
   val c1 = check(1)
   val c1Test: Box[Int] = c1
 
-  def foo[@precise T : Box](arg: T): Box[T] = summon[Box[T]]
+  def foo[@precise T: Box](arg: T): Box[T] = summon[Box[T]]
   object fooTest:
     given Box[1] = new Box[1](1)
     val x = foo(1)
@@ -179,10 +179,26 @@ object preciseCovariance:
   val fbic12Test: Inv[Int, 2] = fbic12
 
 
+object preciseCovariantComposition:
+  object direct:
+    class BoxC[@precise +A]
+    def fromBox[B](x: Box[BoxC[B]]): BoxC[B] = ???
+    val bb1: Box[BoxC[1]] = ???
+    val frombb1 = fromBox(bb1)
+    val frombb1Test: BoxC[1] = frombb1
+
+  object boring:
+    class BoxC[@precise +A]
+    def fromBox[B](x: BoxC[(1, B)]): BoxC[B] = ???
+    val b1: BoxC[(1, 1)] = ???
+    val fromb1 = fromBox(b1)
+    val fromb1Test: BoxC[1] = fromb1
+
+
 object preciseCovariantOpaque:
   opaque type BoxC[@precise +A] = A
   def fromBox[B <: Any](x: BoxC[B]): BoxC[B] = x
-  val b1 : BoxC[1] = ???
+  val b1: BoxC[1] = ???
   val b11 = fromBox(b1)
   val b11Test: BoxC[1] = b11
 
@@ -264,14 +280,14 @@ object preciseCovarianceWithCompiletimeOps:
   import compiletime.ops.int.+
   class Inlined[@precise +T <: Int]
   extension [T <: Int](lhs: Inlined[T])
-    def inc : Inlined[T + 1] = ???
+    def inc: Inlined[T + 1] = ???
 
   val i1 = Inlined[1]
   val i3: Inlined[3] = i1.inc.inc
 
 
 object preciseByName:
-  def id[@precise T](t : => T): Box[T] = ???
+  def id[@precise T](t: => T): Box[T] = ???
   val x = id(1)
   val xTest: Box[1] = x
   val y = id((1, 2))
@@ -280,7 +296,7 @@ object preciseByName:
 
 object preciseFuncX:
   object func0:
-    def id[@precise T](t : () => T): Box[T] = ???
+    def id[@precise T](t: () => T): Box[T] = ???
     val x = id(() => 1)
     val xTest: Box[1] = x
     val y = id(() => (1, 2))
@@ -357,9 +373,9 @@ object preciseImplicitConversion:
 
 
 object preciseImplicitConversionNewStyle:
-  given toBoxFromTuple[@precise T <: Tuple] : Conversion[T, Box[T]] = Box(_)
-  given toBoxFromInt[@precise T <: Int] : Conversion[T, Box[T]] = Box(_)
-  given toBoxFromString[T <: String] : Conversion[T, Box[T]] = Box(_)
+  given toBoxFromTuple[@precise T <: Tuple]: Conversion[T, Box[T]] = Box(_)
+  given toBoxFromInt[@precise T <: Int]: Conversion[T, Box[T]] = Box(_)
+  given toBoxFromString[T <: String]: Conversion[T, Box[T]] = Box(_)
   def box[T1, T2, T3, @precise T4, T5](
     b1: Box[T1], b2: Box[T2], r: Int, b3: Box[T3]
   )(
@@ -375,7 +391,7 @@ object preciseImplicitConversionNewStyle:
 
 object precisePolymorphicTypesAndValues:
   type Id1 = [@precise T] => T => Box[T]
-  val id1Check: Id1 = [T] => (t : T) => Box(t) // error
+  val id1Check: Id1 = [T] => (t: T) => Box(t) // error
 
   type Id2 = [T] => T => Box[T]
   val id2Check: Id2 = [@precise T] => (t: T) => Box(t) // error