[Experiment] Precise annotation

Author: mbovel

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

@@ -12,7 +12,7 @@ import config.Printers.typr
 import typer.ProtoTypes.{newTypeVar, representedParamRef}
 import UnificationDirection.*
 import NameKinds.AvoidNameKind
-
+import annotation.tailrec
 /** Methods for adding constraints and solving them.
  *
  * What goes into a Constraint as opposed to a ConstrainHandler?
@@ -545,8 +545,46 @@ trait ConstraintHandling {
       case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
 
+    def derivesPreciseAnnot(tp: Type): Boolean =
+      tp.derivesAnnotWith(_.matches(defn.PreciseAnnot))
+
+    def dependsOnParam(tp: Type, param: TypeParamRef) : Boolean =
+      tp match
+        case v: TypeVar => v.origin == param
+        case AppliedType(_, args) => args.exists(dependsOnParam(_, param))
+        case _ => false
+
+    def isPreciseRecur(tp: Type, uninstParams : List[TypeParamRef]): Boolean = tp match
+      //the type parameter is annotated as precise
+      case param: TypeParamRef if derivesPreciseAnnot(param) => true
+      case param: TypeParamRef =>
+        //the type parameter is from an applied type and there it is annotated as precise
+        val preciseTypeParam = constraint.domainLambdas.view.flatMap(_.resType.paramInfoss.flatten).flatMap {
+          case AppliedType(tycon, args) =>
+            val preciseArgIdx = tycon.typeParams.indexWhere(t => derivesPreciseAnnot(t.paramInfo.hiBound))
+            if (preciseArgIdx >= 0) Some(args(preciseArgIdx) == param)
+            else None
+          case p : TypeParamRef => if (p == param) Some(false) else None
+          case _ => None
+        }.headOption.getOrElse(false)
+        if preciseTypeParam then true
+        //the type parameter is being dependent upon a different precise type parameter
+        else if uninstParams.nonEmpty then
+          val nextParams = uninstParams.view.dropWhile(_ != param).drop(1).toList
+          //getting all the dependent parameters to check if they are precise
+          val dependent = nextParams.filter(v => dependsOnParam(constraint.entry(v).loBound, param))
+          //TODO: THIS IS HACK THAT WORKS FOR TRIVIAL CASES
+          if dependent.isEmpty && nextParams.nonEmpty && constraint.entry(nextParams.last).loBound == defn.NothingType then
+            isPreciseRecur(nextParams.last, Nil)
+          else dependent.exists(isPreciseRecur(_, nextParams))
+        else false
+      case _ => false
+
+    def isPrecise(tp: Type): Boolean =
+      isPreciseRecur(tp, constraint.uninstVars.view.reverse.map(_.origin).toList)
+
     val wideInst =
-      if isSingleton(bound) then inst
+      if isSingleton(bound) || isPrecise(bound) then inst
       else dropTransparentTraits(widenIrreducible(widenOr(widenSingle(inst))), bound)
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
@@ -562,6 +600,8 @@ trait ConstraintHandling {
    *  is also a singleton type.
    */
   def instanceType(param: TypeParamRef, fromBelow: Boolean)(using Context): Type = {
+//    println("============================")
+//    println(constraint.show)
     val approx = approximation(param, fromBelow).simplified
     if fromBelow then
       val widened = widenInferred(approx, param)

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

@@ -962,6 +962,7 @@ class Definitions {
   @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
   @tu lazy val TransparentTraitAnnot: ClassSymbol = requiredClass("scala.annotation.transparentTrait")
   @tu lazy val NativeAnnot: ClassSymbol = requiredClass("scala.native")
+  @tu lazy val PreciseAnnot: ClassSymbol = requiredClass("scala.annotation.precise")
   @tu lazy val RepeatedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Repeated")
   @tu lazy val SourceFileAnnot: ClassSymbol = requiredClass("scala.annotation.internal.SourceFile")
   @tu lazy val ScalaSignatureAnnot: ClassSymbol = requiredClass("scala.reflect.ScalaSignature")

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

@@ -13,6 +13,8 @@ object TypeEval:
     case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) =>
       extension (tp: Type) def fixForEvaluation: Type =
         tp.normalized.dealias match
+          // deeper evaluation required
+          case tp : AppliedType => tryCompiletimeConstantFold(tp)
           // enable operations for constant singleton terms. E.g.:
           // ```
           // final val one = 1

library/src/scala/annotation/precise.scala

@@ -0,0 +1,8 @@
+package scala.annotation
+
+import scala.annotation.Annotation
+
+@experimental
+class precise extends Annotation {
+
+}

project/MiMaFilters.scala

@@ -30,5 +30,8 @@ object MiMaFilters {
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeTreeModule.ref"),
 
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.since"),
+
+    // APIs will be added in 3.3.0
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.precise"),
   )
 }

tests/neg/precise-type-params.scala

@@ -0,0 +1,145 @@
+import annotation.precise
+import language.implicitConversions
+
+object preciseDefs:
+  def id[T <: Any@precise](x: T): T = x
+  class Box[T]
+  def idBox[T <: Any@precise](t: T): Box[T] = ???
+
+  final val x = id(3)
+  val xTest: 3 = x
+
+  final val x3 = id(id(id(3)))
+  val x3Test: 3 = x3
+
+  final val tpl = id((1, 2))
+  val tplTest: (1, 2) = tpl
+
+  final val tpl2 = id((1, 2, (3, 4)))
+  val tpl2Test: (1, 2, (3, 4)) = tpl2
+
+  final val list1 = id(1 :: Nil)
+  val list1Test: List[1] = list1
+
+  final val list1hi = id(1 :: "hi" :: Nil)
+  val list1hiTest: List[1 | "hi"] = list1hi
+
+  val c : Boolean = ???
+  val ifVal = idBox(if c then 2 else 3)
+  val ifValTest: Box[2 | 3] = ifVal
+
+  def same[T <: Any@precise](x: T, y: T) : Box[T] = ???
+  final val sameVal = same(1, 2)
+  val sameValTest: Box[1 | 2] = sameVal
+
+  def sameVarArgs[T <: Any@precise](a: T*) : Box[T] = ???
+  final val sameVal123hi = sameVarArgs(1, 2, 3, "hi")
+  val sameVal123hiTest: Box[1 | 2 | 3 | "hi"] = sameVal123hi
+
+  def dep1[T1 <: Any@precise, T2 <: T1](t1: T1)(t2: T2): Box[T1] = ???
+  val d1 = dep1(1)(2) //error
+
+  def dep2[T1 <: Any, T2 <: T1@precise](t1: T1)(t2: T2): Box[T1] = ???
+  final val d2 = dep2(1)(2)
+  val d2Test: Box[Int] = d2
+
+  def dep12[T1 <: Any@precise, T2 <: T1@precise](t1: T1)(t2: T2): Box[T1] = ???
+  final val d12 = dep12(1)(2)
+  val d12Test: Box[1 | 2] = d12
+
+  class PreciseBox[T <: Any@precise]
+  given [T]: PreciseBox[T] with {}
+
+  def check[T](t: T)(using PreciseBox[T]): Box[T] = ???
+  val c1 = check(1)
+  val c1Test: Box[Int] = c1
+
+
+object preciseInvariance:
+  class Box[T <: Any @precise](x: T)
+  val c: Boolean = ???
+  val b = Box(if c then 2 else 3)
+  val bTest: Box[2 | 3] = b
+  final val b3 = Box(Box(Box(3)))
+  val b3Test: Box[Box[Box[3]]] = b3
+
+  final val tpl = Box((1, (2, 3), "hi"))
+  val tplTest: Box[(1, (2, 3), "hi")] = tpl
+
+  final val tpl2: (1, (2, 3), "hi") = (1, (2, 3), "hi")
+  final val tpl3 = Box(tpl2)
+  val tpl3Test: Box[tpl2.type] = tpl3
+
+  implicit def toBox[T <: Any @precise](from: T): Box[T] = Box(from)
+  def box[T](b: Box[T]): Box[T] = b
+
+  final val btpl = box(((1, 2), (3, 4)))
+  val btplTest: Box[((1, 2), (3, 4))] = btpl
+
+  final val b1 = box(1)
+  val b1Test: Box[1] = b1
+
+  class Boxx[T <: Any@precise](x: T*)
+  val b123 = Boxx(1, 2, 3)
+  val b123Test: Boxx[1 | 2 | 3] = b123
+
+
+object preciseCovariance:
+  class Box[+A <: Any@precise](x: A)
+  def fromBox[B <: Any](x: Box[B]): Box[B] = x
+  final val b1 = Box(1)
+  val b11 = fromBox(b1)
+  val b11Test: Box[1] = b11
+  val b11CovTest: Box[Int] = b11
+
+  class Inv[A, B]
+  class BoxCI[+C <: Any@precise, +I](c: C, i: I)
+  def fromBoxCI[C, I](x: BoxCI[C, I]): Inv[C, I] = ???
+  val bci = BoxCI(1, 2)
+  val bciTest: BoxCI[1, Int] = bci
+  val fbci = fromBoxCI(bci)
+  val fbciTest: Inv[1, Int] = fbci
+  val fbci12 = fromBoxCI(??? : BoxCI[1, 2])
+  val fbci12Test: Inv[1, Int] = fbci12
+
+  class BoxIC[+I, +C <: Any@precise](i: I, c: C)
+  def fromBoxIC[I, C](x: BoxIC[I, C]): Inv[I, C] = ???
+  val bic = BoxIC(1, 2)
+  val bicTest: BoxIC[Int, 2] = bic
+  val fbic = fromBoxIC(bic)
+  val fbicTest: Inv[Int, 2] = fbic
+  val fbic12 = fromBoxIC(??? : BoxIC[1, 2])
+  val fbic12Test: Inv[Int, 2] = fbic12
+
+
+object preciseCovarianceWithCompiletimeOps:
+  import compiletime.ops.int.+
+  class Inlined[+T <: Int @precise]
+  extension [T <: Int](lhs: Inlined[T])
+    def inc : Inlined[T + 1] = ???
+
+  val i1 = Inlined[1]
+  val i3: Inlined[3] = i1.inc.inc
+
+
+object preciseEquals:
+  class Box[T]
+  class Foo:
+    def ==[R <: Any@precise](r: R): Box[R] = ???
+
+  val f = new Foo
+  val x = f == ((1, 2), 3)
+  val xTest: Box[((1, 2), 3)] = x
+
+
+/*
+  errors we are not supposed to have
+*/
+object problems:
+  class Box[T]
+  def idBox[T <: Any@precise](t: T): Box[T] = ???
+  def idBoxBox[BB](x: Box[BB]): Box[BB] = x
+
+  val b1 = idBoxBox(idBox(1))
+  val b1Test: Box[1] = b1
+