Precise annotation SIP

Author: mbovel

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -256,6 +256,16 @@ object desugar {
           evidenceParamBuf.toList)
   end elimContextBounds
 
+  def isPreciseAnnot(tree: untpd.Tree)(using Context): Boolean =
+    tree match
+      case Apply(Select(New(clsSel), _), Nil) =>
+        inContext(ctx.fresh.setReporter(Reporter.NoReporter).setExploreTyperState()) {
+          try
+            ctx.typer.typedExpr(clsSel).tpe.classSymbol == defn.PreciseAnnot
+          catch case _ : Throwable => false
+        }
+      case _ => false
+
   def addDefaultGetters(meth: DefDef)(using Context): Tree =
 
     /** The longest prefix of parameter lists in paramss whose total number of
@@ -293,14 +303,33 @@ object desugar {
         vparam => toDefParam(vparam, keepAnnotations = true, keepDefault = false)
       }
 
+    // gets arguments should be considered precise
+    val paramPrecises: List[Boolean] =
+      // indication for the type parameters preciseness
+      val preciseMap : Map[TypeName, Boolean] =
+        meth.leadingTypeParams.map(t => (t.name, t.mods.annotations.exists(isPreciseAnnot))).toMap
+      // mapping type parameters preciseness onto term parameter preciseness
+      meth.termParamss.view.flatten.map(p => p.tpt).map {
+        case Ident(n) => preciseMap.getOrElse(n.asTypeName, false)
+        case _ => false
+      }.toList
+
     def defaultGetters(paramss: List[ParamClause], n: Int): List[DefDef] = paramss match
       case ValDefs(vparam :: vparams) :: paramss1 =>
         def defaultGetter: DefDef =
+          val (rhs, tpt) =
+            // if the parameter is precise, then we add explicit return type for the
+            // definition to keep the precise type after precise typing.
+            if paramPrecises(n) then
+              val rhsTyped = withMode(Mode.Precise){ctx.typer.typedExpr(vparam.rhs)}
+              (TypedSplice(rhsTyped), TypeTree(rhsTyped.tpe))
+            // otherwise, the desugaring is unchanged from the status quo
+            else (vparam.rhs, TypeTree())
           DefDef(
             name = DefaultGetterName(meth.name, n),
             paramss = getterParamss(n),
-            tpt = TypeTree(),
-            rhs = vparam.rhs
+            tpt = tpt,
+            rhs = rhs
           )
           .withMods(Modifiers(
             meth.mods.flags & (AccessFlags | Synthetic) | (vparam.mods.flags & Inline),
@@ -381,9 +410,10 @@ object desugar {
 
   @sharable private val synthetic = Modifiers(Synthetic)
 
-  private def toDefParam(tparam: TypeDef, keepAnnotations: Boolean): TypeDef = {
+  private def toDefParam(tparam: TypeDef, keepAnnotations: Boolean)(using Context): TypeDef = {
     var mods = tparam.rawMods
-    if (!keepAnnotations) mods = mods.withAnnotations(Nil)
+    val onlyPreciseAnnot = mods.annotations.filter(isPreciseAnnot)
+    if (!keepAnnotations) mods = mods.withAnnotations(onlyPreciseAnnot)
     tparam.withMods(mods & EmptyFlags | Param)
   }
   private def toDefParam(vparam: ValDef, keepAnnotations: Boolean, keepDefault: Boolean): ValDef = {

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -286,6 +286,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     end recur
 
     val (rtp, paramss) = recur(sym.info, sym.rawParamss)
+    val typeParamsSyms = paramss.view.flatten.filter(_.isType).toList
+    @tailrec def allPrecises(tp: Type, precises: List[Boolean]): List[Boolean] =
+      tp match
+        case pt : PolyType => allPrecises(pt.resType, precises ++ pt.paramPrecises)
+        case mt : MethodType => allPrecises(mt.resType, precises)
+        case _ => precises
+    val paramPrecises = allPrecises(sym.info, Nil)
+    paramPrecises.lazyZip(typeParamsSyms).foreach {
+      case (true, p) => p.addAnnotation(defn.PreciseAnnot)
+      case _ =>
+    }
     DefDef(sym, paramss, rtp, rhsFn(paramss.nestedMap(ref)))
   end DefDef
 

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -405,7 +405,7 @@ extends tpd.TreeTraverser:
           info match
             case mt: MethodOrPoly =>
               val psyms = psymss.head
-              mt.companion(mt.paramNames)(
+              mt.companion(mt.paramNames, mt.paramPrecises)(
                 mt1 =>
                   if !psyms.exists(_.isUpdatedAfter(preRecheckPhase)) && !mt.isParamDependent && prevLambdas.isEmpty then
                     mt.paramInfos

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

@@ -14,7 +14,7 @@ import UnificationDirection.*
 import NameKinds.AvoidNameKind
 import util.SimpleIdentitySet
 import NullOpsDecorator.stripNull
-
+import annotation.tailrec
 /** Methods for adding constraints and solving them.
  *
  * What goes into a Constraint as opposed to a ConstrainHandler?
@@ -647,7 +647,8 @@ trait ConstraintHandling {
       case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
 
     val wideInst =
-      if isSingleton(bound) then inst
+      //keeping the precise type if the bound is Singleton or precise or the mode is precise
+      if isSingleton(bound) || ctx.mode.is(Mode.Precise) || bound.isPrecise 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

@@ -133,7 +133,7 @@ class Definitions {
           val underlyingName = name.asSimpleName.drop(6)
           val underlyingClass = ScalaPackageVal.requiredClass(underlyingName)
           denot.info = TypeAlias(
-            HKTypeLambda(argParamNames :+ "R".toTypeName, argVariances :+ Covariant)(
+            HKTypeLambda(argParamNames :+ "R".toTypeName, Nil, argVariances :+ Covariant)(
               tl => List.fill(arity + 1)(TypeBounds.empty),
               tl => CapturingType(underlyingClass.typeRef.appliedTo(tl.paramRefs),
                 CaptureSet.universal)
@@ -187,7 +187,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 {
@@ -719,7 +719,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
@@ -988,6 +988,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/Mode.scala

@@ -11,7 +11,7 @@ case class Mode(val bits: Int) extends AnyVal {
   def isExpr: Boolean = (this & PatternOrTypeBits) == None
 
   override def toString: String =
-    (0 until 31).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
+    (0 until 32).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
 
   def ==(that: Mode): Boolean = this.bits == that.bits
   def !=(that: Mode): Boolean = this.bits != that.bits
@@ -129,4 +129,9 @@ object Mode {
    *  Type `Null` becomes a subtype of non-primitive value types in TypeComparer.
    */
   val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
+
+  /**
+   * Indication that argument widening should not take place.
+   */
+  val Precise: Mode = newMode(31, "Precise")
 }

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

@@ -540,7 +540,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

@@ -1491,6 +1491,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

@@ -22,7 +22,7 @@ import scala.util.control.NonFatal
 import typer.ProtoTypes.constrained
 import typer.Applications.productSelectorTypes
 import reporting.trace
-import annotation.constructorOnly
+import annotation.{constructorOnly, tailrec}
 import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam}
 
 /** Provides methods to compare types.
@@ -1097,7 +1097,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(
@@ -2103,7 +2103,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    *  to override `tp2` ? This is the case if they're pairwise >:>.
    */
   def matchingPolyParams(tp1: PolyType, tp2: PolyType): Boolean = {
-    def loop(formals1: List[Type], formals2: List[Type]): Boolean = formals1 match {
+    @tailrec def loop(formals1: List[Type], formals2: List[Type]): Boolean = formals1 match {
       case formal1 :: rest1 =>
         formals2 match {
           case formal2 :: rest2 =>
@@ -2116,7 +2116,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case nil =>
         formals2.isEmpty
     }
-    loop(tp1.paramInfos, tp2.paramInfos)
+    tp1.paramPrecises == tp2.paramPrecises && loop(tp1.paramInfos, tp2.paramInfos)
   }
 
   // Type equality =:=
@@ -2456,6 +2456,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

@@ -12,6 +12,7 @@ import collection.mutable
 import java.lang.ref.WeakReference
 import util.{Stats, SimpleIdentityMap}
 import Decorators._
+import ast.tpd.Tree
 
 import scala.annotation.internal.sharable
 
@@ -24,21 +25,23 @@ object TyperState {
       .setCommittable(true)
 
   type LevelMap = SimpleIdentityMap[TypeVar, Integer]
+  type PreciseConversionStack = List[Set[Tree]]
 
-  opaque type Snapshot = (Constraint, TypeVars, LevelMap)
+  opaque type Snapshot = (Constraint, TypeVars, LevelMap, PreciseConversionStack)
 
   extension (ts: TyperState)
     def snapshot()(using Context): Snapshot =
-      (ts.constraint, ts.ownedVars, ts.upLevels)
+      (ts.constraint, ts.ownedVars, ts.upLevels, ts.myPreciseConvStack)
 
     def resetTo(state: Snapshot)(using Context): Unit =
-      val (constraint, ownedVars, upLevels) = state
+      val (constraint, ownedVars, upLevels, myPreciseConvStack) = state
       for tv <- ownedVars do
         if !ts.ownedVars.contains(tv) then // tv has been instantiated
           tv.resetInst(ts)
       ts.constraint = constraint
       ts.ownedVars = ownedVars
       ts.upLevels = upLevels
+      ts.myPreciseConvStack = myPreciseConvStack
 }
 
 class TyperState() {
@@ -93,6 +96,15 @@ class TyperState() {
 
   private var upLevels: LevelMap = _
 
+  private var myPreciseConvStack: List[Set[Tree]] = _
+  def hasPreciseConversion(tree: Tree): Boolean = myPreciseConvStack.head.contains(tree)
+  def addPreciseConversion(tree: Tree): Unit =
+    myPreciseConvStack = (myPreciseConvStack.head + tree) :: myPreciseConvStack.tail
+  def pushPreciseConversionStack(): Unit  =
+    myPreciseConvStack = Set.empty[Tree] :: myPreciseConvStack
+  def popPreciseConversionStack(): Unit =
+    myPreciseConvStack = myPreciseConvStack.drop(1)
+
   /** Initializes all fields except reporter, isCommittable, which need to be
    *  set separately.
    */
@@ -105,6 +117,7 @@ class TyperState() {
     this.myOwnedVars = SimpleIdentitySet.empty
     this.upLevels = SimpleIdentityMap.empty
     this.isCommitted = false
+    this.myPreciseConvStack = Nil
     this
 
   /** A fresh typer state with the same constraint as this one. */
@@ -115,6 +128,7 @@ class TyperState() {
       .setReporter(reporter)
       .setCommittable(committable)
     ts.upLevels = upLevels
+    ts.myPreciseConvStack = myPreciseConvStack
     ts
 
   /** The uninstantiated variables */
@@ -162,6 +176,8 @@ class TyperState() {
     assert(!isCommitted, s"$this is already committed")
     val targetState = ctx.typerState
 
+    targetState.myPreciseConvStack = myPreciseConvStack
+
     val nothingToCommit = (constraint eq targetState.constraint) && !reporter.hasUnreportedMessages
     assert(!targetState.isCommitted || nothingToCommit ||
        // Committing into an already committed TyperState usually doesn't make