add checks for proper precise aliasing, extending, and overriding

Author: soronpo

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.
@@ -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 =:=

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -6,7 +6,7 @@ import scala.collection.mutable
 import core._
 import dotty.tools.dotc.typer.Checking
 import dotty.tools.dotc.inlines.Inlines
-import dotty.tools.dotc.typer.VarianceChecker
+import dotty.tools.dotc.typer.{VarianceChecker, PreciseChecker}
 import typer.ErrorReporting.errorTree
 import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
 import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
@@ -388,6 +388,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             annotateExperimental(sym)
             tree.rhs match
               case impl: Template =>
+                if (!sym.is(Flags.Given)) // skipping over given classes that are generated from `given ... with {}`
+                  PreciseChecker.checkClass(impl)
                 for parent <- impl.parents do
                   Checking.checkTraitInheritance(parent.tpe.classSymbol, sym.asClass, parent.srcPos)
             // Add SourceFile annotation to top-level classes
@@ -403,6 +405,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               Checking.checkGoodBounds(tree.symbol)
             (tree.rhs, sym.info) match
               case (rhs: LambdaTypeTree, bounds: TypeBounds) =>
+                PreciseChecker.checkLambda(rhs, sym.isOpaqueAlias)
                 VarianceChecker.checkLambda(rhs, bounds)
                 if sym.isOpaqueAlias then
                   VarianceChecker.checkLambda(rhs, TypeBounds.upper(sym.opaqueAlias))

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

@@ -0,0 +1,49 @@
+package dotty.tools.dotc
+package typer
+
+import dotty.tools.dotc.ast.{ Trees, tpd }
+import core.*
+import Types.*, Contexts.*, Trees.*
+import Decorators.*
+
+object PreciseChecker:
+  enum Mode:
+    case SamePrecise, AllowMorePrecise, AllowLessPrecise
+  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
+
+        def label(precise: Boolean): String = if (precise) "precise" else "imprecise"
+        args.view.zipWithIndex.foreach {
+          case (a: TypeRef, i) if a.symbol.name.isTypeName =>
+            val paramName = a.symbol.name.asTypeName
+            val appliedParamPrecise = appliedParamPreciseList(i)
+            tdefParamPreciseMap.get(paramName).foreach { tdefParamPrecise =>
+              val preciseMismatch = mode match
+                case Mode.SamePrecise => tdefParamPrecise != appliedParamPrecise
+                case Mode.AllowMorePrecise => !tdefParamPrecise && appliedParamPrecise
+                case Mode.AllowLessPrecise => tdefParamPrecise && !appliedParamPrecise
+              if preciseMismatch then
+                val pos = tparams.find(_.name == paramName).get.srcPos
+                report.error(em"${label(tdefParamPrecise)} type parameter $paramName occurs in ${label(appliedParamPrecise)} position in $tpe", pos)
+            }
+          case _ =>
+        }
+      case _ =>
+
+  def checkClass(tree: tpd.Template)(using Context): Unit =
+    val tparams = tree.constr.leadingTypeParams
+    tree.parents.view.map(_.tpe.dealias).foreach(check(tparams, _, Mode.AllowMorePrecise))
+
+  def checkLambda(tree: tpd.LambdaTypeTree, isOpaque: Boolean)(using Context): Unit =
+    tree.body.tpe.dealiasKeepOpaques match
+      case at: AppliedType =>
+        val mode = if (isOpaque) Mode.SamePrecise else Mode.AllowLessPrecise
+        check(tree.tparams, at, mode)
+      case tb: TypeBounds =>
+        check(tree.tparams, tb.hi, Mode.AllowMorePrecise)
+        check(tree.tparams, tb.lo, Mode.AllowLessPrecise)
+      case _ =>

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

@@ -409,6 +409,14 @@ object RefChecks {
         !(syms1 exists (set2 contains _))
       }
 
+      def samePrecises(memberTp: Type, otherTp: Type): Boolean =
+        (memberTp, otherTp) match
+          case (mpt: PolyType, otp: PolyType) =>
+            mpt.paramPrecises == otp.paramPrecises
+          case (TypeBounds(_, mptHi: TypeLambda), TypeBounds(_, otpHi: TypeLambda)) =>
+            mptHi.paramPrecises == otpHi.paramPrecises
+          case _ => true
+
       // o: public | protected        | package-protected  (aka java's default access)
       // ^-may be overridden by member with access privileges-v
       // m: public | public/protected | public/protected/package-protected-in-same-package-as-o
@@ -509,6 +517,8 @@ object RefChecks {
       else if (!compatTypes(memberTp(self), otherTp(self)) &&
                  !compatTypes(memberTp(upwardsSelf), otherTp(upwardsSelf)))
         overrideError("has incompatible type", compareTypes = true)
+      else if (!samePrecises(memberTp(self), otherTp(self)))
+        overrideError("has different precise type parameter annotations")
       else if (member.targetName != other.targetName)
         if (other.targetName != other.name)
           overrideError(i"needs to be declared with @targetName(${"\""}${other.targetName}${"\""}) so that external names match")