Add missing Erased flag to inline bindings

Fixes #11996

Author: nicolasstucki

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

@@ -889,6 +889,7 @@ class Definitions {
   @tu lazy val ImplicitAmbiguousAnnot: ClassSymbol = requiredClass("scala.annotation.implicitAmbiguous")
   @tu lazy val ImplicitNotFoundAnnot: ClassSymbol = requiredClass("scala.annotation.implicitNotFound")
   @tu lazy val InlineParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InlineParam")
+  @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
   @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")

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

@@ -3638,9 +3638,15 @@ object Types {
         case ExprType(resType) => ExprType(AnnotatedType(resType, Annotation(defn.InlineParamAnnot)))
         case _ => AnnotatedType(tp, Annotation(defn.InlineParamAnnot))
       }
+      def translateErased(tp: Type): Type = tp match {
+        case ExprType(resType) => ExprType(AnnotatedType(resType, Annotation(defn.ErasedParamAnnot)))
+        case _ => AnnotatedType(tp, Annotation(defn.ErasedParamAnnot))
+      }
       def paramInfo(param: Symbol) = {
-        val paramType = param.info.annotatedToRepeated
-        if (param.is(Inline)) translateInline(paramType) else paramType
+        var paramType = param.info.annotatedToRepeated
+        if (param.is(Inline)) paramType = translateInline(paramType)
+        if (param.is(Erased)) paramType = translateErased(paramType)
+        paramType
       }
 
       apply(params.map(_.name.asTermName))(

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -219,7 +219,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           toTextGlobal(tp.resultType)
         }
       case AnnotatedType(tpe, annot) =>
-        if annot.symbol == defn.InlineParamAnnot then toText(tpe)
+        if annot.symbol == defn.InlineParamAnnot || annot.symbol == defn.ErasedParamAnnot then toText(tpe)
         else toTextLocal(tpe) ~ " " ~ toText(annot)
       case tp: TypeVar =>
         if (tp.isInstantiated)

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

@@ -467,6 +467,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     var bindingFlags: FlagSet = InlineProxy
     if formal.widenExpr.hasAnnotation(defn.InlineParamAnnot) then
       bindingFlags |= Inline
+    if formal.widenExpr.hasAnnotation(defn.ErasedParamAnnot) then
+      bindingFlags |= Erased
     if isByName then
       bindingFlags |= Method
     val boundSym = newSym(InlineBinderName.fresh(name.asTermName), bindingFlags, bindingType).asTerm

library/src/scala/annotation/internal/ErasedParam.scala

@@ -0,0 +1,6 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation produced by Namer to indicate an erased parameter */
+final class ErasedParam() extends Annotation

library/src/scala/annotation/internal/TransparentParam.scala renamed to library/src/scala/annotation/internal/InlineParam.scala

@@ -0,0 +1,23 @@
+final class UnivEq[A]
+
+object UnivEq:
+  erased def force[A]: UnivEq[A] =
+    compiletime.erasedValue
+
+extension [A](a: A)
+  inline def ==*[B >: A](b: B)(using erased UnivEq[B]): Boolean = a == b
+  inline def !=*[B >: A](b: B)(using erased UnivEq[B]): Boolean = a != b
+
+case class I(i: Int)
+
+@main def Test = {
+  def test[A](a: A, b: A): Unit = {
+    erased given UnivEq[A] = UnivEq.force[A]
+    assert(a ==* a)
+    assert(a !=* b)
+  }
+  println("Test starting...")
+  test(I(1), I(2)) // error
+  test(1, 2)
+  test(true, false)
+}