[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,35 @@ 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 param.isPrecise | ctx.typerState.precise => true
+      case param: TypeParamRef =>
+        //the type parameter is from an applied type and there it is annotated as precise
+        constraint.domainLambdas.view.flatMap(_.resType.paramInfoss.flatten).flatMap {
+          case AppliedType(tycon, args) =>
+            val preciseArgIdx = tycon.typeParamSymbols.indexWhere(_.paramPrecise)
+            if (preciseArgIdx >= 0) Some(args(preciseArgIdx) == param)
+            else None
+          case p : TypeParamRef => if (p == param) Some(false) else None
+          case _ => None
+        }.headOption.getOrElse(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) =>

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

@@ -164,7 +164,7 @@ class Definitions {
                     useCompleter: Boolean = false) = {
     val tparamNames = PolyType.syntheticParamNames(typeParamCount)
     val tparamInfos = tparamNames map (_ => bounds)
-    def ptype = PolyType(tparamNames)(_ => tparamInfos, resultTypeFn)
+    def ptype = PolyType(tparamNames, Nil)(_ => tparamInfos, resultTypeFn)
     val info =
       if (useCompleter)
         new LazyType {
@@ -695,7 +695,7 @@ class Definitions {
                   case meth: MethodType =>
                     info.derivedLambdaType(
                       resType = meth.derivedLambdaType(
-                      paramNames = Nil, paramInfos = Nil))
+                      paramNames = Nil, paramPrecises = Nil, paramInfos = Nil))
                 }
             }
             val argConstr = constr.copy().entered
@@ -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/Denotations.scala

@@ -546,7 +546,7 @@ object Denotations {
              && tp1.isErasedMethod == tp2.isErasedMethod =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
-              tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
+              tp1.derivedLambdaType(mergeParamNames(tp1, tp2), Nil, tp1.paramInfos, resType)
             else NoType
           case _ => NoType
       case tp1: PolyType =>
@@ -556,6 +556,7 @@ object Denotations {
             if resType.exists then
               tp1.derivedLambdaType(
                 mergeParamNames(tp1, tp2),
+                Nil,
                 tp1.paramInfos.zipWithConserve(tp2.paramInfos)( _ & _ ),
                 resType)
             else NoType

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

@@ -91,7 +91,7 @@ final class ProperGadtConstraint private(
   override def addToConstraint(params: List[Symbol])(using Context): Boolean = {
     import NameKinds.DepParamName
 
-    val poly1 = PolyType(params.map { sym => DepParamName.fresh(sym.name.toTypeName) })(
+    val poly1 = PolyType(params.map { sym => DepParamName.fresh(sym.name.toTypeName) }, params.map(_.paramPrecise))(
       pt => params.map { param =>
         // In bound type `tp`, replace the symbols in dependent positions with their internal TypeParamRefs.
         // The replaced symbols will be later picked up in `ConstraintHandling#addToConstraint`

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

@@ -523,7 +523,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos: @unchecked
         paramInfos = TypeBounds(lo, LazyRef.of(hi)) :: pinfos1
       }
-      ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
+      ensureFresh(tl.newLikeThis(tl.paramNames, tl.paramPrecises, paramInfos, tl.resultType))
     }
     else tl
 

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

@@ -38,6 +38,9 @@ trait ParamInfo {
   /** The variance of the type parameter */
   def paramVariance(using Context): Variance
 
+  /** The precise enforcement indicator of the type parameter */
+  def paramPrecise(using Context): Boolean
+
   /** The variance of the type parameter, as a number -1, 0, +1.
    *  Bivariant is mapped to 1, i.e. it is treated like Covariant.
    */

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

@@ -1483,6 +1483,11 @@ object SymDenotations {
       else if is(Contravariant) then Contravariant
       else EmptyFlags
 
+    /** The precise enforcement indicator of this type parameter or type member
+     */
+    final def precise(using Context): Boolean =
+      hasAnnotation(defn.PreciseAnnot)
+
     /** The flags to be used for a type parameter owned by this symbol.
      *  Overridden by ClassDenotation.
      */

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

@@ -346,6 +346,12 @@ object Symbols {
     def paramInfoAsSeenFrom(pre: Type)(using Context): Type = pre.memberInfo(this)
     def paramInfoOrCompleter(using Context): Type = denot.infoOrCompleter
     def paramVariance(using Context): Variance = denot.variance
+    def paramPrecise(using Context): Boolean =
+      val owner = denot.owner
+      if (owner.isConstructor)
+        owner.owner.typeParams.exists(p => p.name == name && p.paramPrecise)
+      else
+        denot.precise
     def paramRef(using Context): TypeRef = denot.typeRef
 
 // -------- Printing --------------------------------------------------------

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

@@ -1019,7 +1019,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         variancesConform(remainingTparams, tparams) && {
           val adaptedTycon =
             if d > 0 then
-              HKTypeLambda(remainingTparams.map(_.paramName))(
+              HKTypeLambda(remainingTparams.map(_.paramName), remainingTparams.map(_.paramPrecise))(
                 tl => remainingTparams.map(remainingTparam =>
                   tl.integrate(remainingTparams, remainingTparam.paramInfo).bounds),
                 tl => otherTycon.appliedTo(
@@ -2365,6 +2365,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     else if (tparams1.hasSameLengthAs(tparams2))
       HKTypeLambda(
         paramNames = HKTypeLambda.syntheticParamNames(tparams1.length),
+        paramPrecises = Nil,
         variances =
           if tp1.isDeclaredVarianceLambda && tp2.isDeclaredVarianceLambda then
             tparams1.lazyZip(tparams2).map((p1, p2) => combineVariance(p1.paramVariance, p2.paramVariance))

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

@@ -234,7 +234,7 @@ object TypeErasure {
 
     def eraseParamBounds(tp: PolyType): Type =
       tp.derivedLambdaType(
-        tp.paramNames, tp.paramNames map (Function.const(TypeBounds.upper(defn.ObjectType))), tp.resultType)
+        tp.paramNames, tp.paramPrecises, tp.paramNames map (Function.const(TypeBounds.upper(defn.ObjectType))), tp.resultType)
 
     if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
     else if (sym.isAbstractType) TypeAlias(WildcardType)
@@ -642,14 +642,14 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
-          tp.derivedLambdaType(names ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
+          tp.derivedLambdaType(names ++ rt.paramNames, Nil, formals ++ rt.paramInfos, rt.resultType)
         case NoType =>
           // Can happen if we smuggle in a Nothing in the qualifier. Normally we prevent that
           // in Checking.checkMembersOK, but compiler-generated code can bypass this test.
           // See i15377.scala for a test case.
           NoType
         case rt =>
-          tp.derivedLambdaType(names, formals, rt)
+          tp.derivedLambdaType(names, Nil, formals, rt)
       }
     case tp: PolyType =>
       this(tp.resultType)

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

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

@@ -89,6 +89,10 @@ class TyperState() {
   def ownedVars: TypeVars = myOwnedVars
   def ownedVars_=(vs: TypeVars): Unit = myOwnedVars = vs
 
+  private var myPrecise: Boolean = false
+  def precise : Boolean = myPrecise
+  def precise_=(p : Boolean): Unit = myPrecise = p
+
   /** Initializes all fields except reporter, isCommittable, which need to be
    *  set separately.
    */
@@ -100,6 +104,10 @@ class TyperState() {
     this.previousConstraint = constraint
     this.myOwnedVars = SimpleIdentitySet.empty
     this.isCommitted = false
+    previous match
+      case ts : TyperState =>
+        this.precise = ts.precise
+      case null =>
     this
 
   /** A fresh typer state with the same constraint as this one. */