Base implementation on internal alias type

Base implementation on internal alias type instead of annotation. This makes
convertibleTo handling unforgeable. It also avoids the need to create a new
class.

Author: odersky

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

@@ -615,6 +615,9 @@ class Definitions {
 
   @tu lazy val RepeatedParamClass: ClassSymbol = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
 
+  @tu lazy val ConvertibleToType: TypeSymbol = enterAliasType(
+    tpnme.CONVERTIBLE_TO, HKTypeLambda(TypeBounds.empty :: Nil)(_.paramRefs(0)))
+
   // fundamental classes
   @tu lazy val StringClass: ClassSymbol = requiredClass("java.lang.String")
   def StringType: Type = StringClass.typeRef
@@ -902,7 +905,6 @@ class Definitions {
   @tu lazy val BodyAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Body")
   @tu lazy val ChildAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Child")
   @tu lazy val ContextResultCountAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ContextResultCount")
-  @tu lazy val ConvertibleAnnot: ClassSymbol = requiredClass("scala.annotation.internal.$convertible")
   @tu lazy val ProvisionalSuperClassAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ProvisionalSuperClass")
   @tu lazy val DeprecatedAnnot: ClassSymbol = requiredClass("scala.deprecated")
   @tu lazy val ImplicitAmbiguousAnnot: ClassSymbol = requiredClass("scala.annotation.implicitAmbiguous")
@@ -1816,6 +1818,7 @@ class Definitions {
       orType,
       RepeatedParamClass,
       ByNameParamClass2x,
+      ConvertibleToType,
       AnyValClass,
       NullClass,
       NothingClass,

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

@@ -286,6 +286,7 @@ object StdNames {
     val COMPANION: N                = "<companion>"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
+    val CONVERTIBLE_TO: N           = "<convertible-to>"
     val DEFAULT_CASE: N             = "defaultCase$"
     val EVT2U: N                    = "evt2u$"
     val EQEQ_LOCAL_VAR: N           = "eqEqTemp$"
@@ -453,7 +454,6 @@ object StdNames {
     val common: N               = "common"
     val compiletime : N         = "compiletime"
     val conforms_ : N           = "$conforms"
-    val convertible_ : N        = "$convertible"
     val convertibleTo: N        = "convertibleTo"
     val copy: N                 = "copy"
     val currentMirror: N        = "currentMirror"

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

@@ -401,6 +401,10 @@ object Types {
     def isRepeatedParam(using Context): Boolean =
       typeSymbol eq defn.RepeatedParamClass
 
+    /** Is this a parameter type that allows implicit argument converson? */
+    def isConvertibleParam(using Context): Boolean =
+      typeSymbol eq defn.ConvertibleToType
+
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
      */
@@ -3779,23 +3783,26 @@ object Types {
      *   - add @$convertibe to parameters that have an @allowConversions annotation
      */
     def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType =
-      def addAnnotation(tp: Type, cls: ClassSymbol, underStar: Boolean): Type = tp match
+      def addAnnotation(tp: Type, cls: ClassSymbol): Type = tp match
+        case ExprType(resType) => ExprType(addAnnotation(resType, cls))
+        case _ => AnnotatedType(tp, Annotation(cls))
+
+      def addConvertibleTo(tp: Type): Type = tp match
         case ExprType(resType) =>
-          ExprType(addAnnotation(resType, cls, underStar))
-        case tp @ AppliedType(tycon, arg :: Nil)
-        if tycon.typeSymbol == defn.RepeatedParamClass && underStar =>
-          tp.derivedAppliedType(tycon, addAnnotation(arg, cls, underStar) :: Nil)
+          ExprType(addConvertibleTo(resType))
+        case tp @ AppliedType(tycon, arg :: Nil) if tycon.typeSymbol == defn.RepeatedParamClass =>
+          tp.derivedAppliedType(tycon, addConvertibleTo(arg) :: Nil)
         case _ =>
-          AnnotatedType(tp, Annotation(cls))
+          AppliedType(defn.ConvertibleToType.typeRef, tp :: Nil)
 
       def paramInfo(param: Symbol) =
         var paramType = param.info.annotatedToRepeated
         if param.is(Inline) then
-          paramType = addAnnotation(paramType, defn.InlineParamAnnot, underStar = false)
+          paramType = addAnnotation(paramType, defn.InlineParamAnnot)
         if param.is(Erased) then
-          paramType = addAnnotation(paramType, defn.ErasedParamAnnot, underStar = false)
+          paramType = addAnnotation(paramType, defn.ErasedParamAnnot)
         if param.hasAnnotation(defn.AllowConversionsAnnot) then
-          paramType = addAnnotation(paramType, defn.ConvertibleAnnot, underStar = true)
+          paramType = addConvertibleTo(paramType)
         paramType
 
       apply(params.map(_.name.asTermName))(

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

@@ -219,6 +219,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tp @ AppliedType(tycon, args) =>
         val cls = tycon.typeSymbol
         if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
+        else if tp.isConvertibleParam then "convertibleTo " ~ toText(args.head)
         else if defn.isFunctionClass(cls) then toTextFunction(args, cls.name.isContextFunction, cls.name.isErasedFunction)
         else if tp.tupleArity >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
         else if isInfixType(tp) then

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

@@ -927,13 +927,10 @@ trait Checking {
    */
   def checkImplicitConversionUseOK(tree: Tree, expected: Type)(using Context): Unit =
     val sym = tree.symbol
-    def isConvertibleParam(tp: Type) = tp match
-      case AnnotatedType(_, annot) => annot.symbol == defn.ConvertibleAnnot
-      case _ => false
     if sym.name == nme.apply
        && sym.owner.derivesFrom(defn.ConversionClass)
        && !sym.info.isErroneous
-       && !isConvertibleParam(expected)
+       && !expected.isConvertibleParam
     then
       def conv = methPart(tree) match
         case Select(qual, _) => qual.symbol.orElse(sym.owner)

library/src/scala/annotation/internal/$convertible.scala

@@ -17,6 +17,7 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.compiletime.ops.long$"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#CompilationInfoModule.XmacroSettings"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.quoted.Quotes#reflectModule#CompilationInfoModule.XmacroSettings"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.allowConversions"),
 
     // Private to the compiler - needed for forward binary compatibility
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.since")

project/MiMaFilters.scala

@@ -28,6 +28,10 @@ class ParserOps[T](p: Parser[T]):
         case Success(x, in1) => Success(f(x), in1)
         case fail: Failure => fail
     )
+  def ~> [U](q: => convertibleTo Parser[U]): Parser[U] =
+    (p ~ q).map(_(1))
+  def <~ [U](q: => convertibleTo Parser[U]): Parser[T] =
+    (p ~ q).map(_(0))
   def parseAll(in: Input): ParseResult[T] =
     p.parse(in) match
       case succ @ Success(x, in1) =>
@@ -80,12 +84,11 @@ def Expr: Parser[Double] =
 def Term: Parser[Double] =
   (Factor ~ rep("*" ~ Factor | "/" ~ Factor)).map(reduce)
 def Factor: Parser[Double] =
-    Number
-  | ("(" ~ Expr ~ ")").map{ case "(" ~~ e ~~ ")" => e }
+  Number | "(" ~> Expr <~ ")"
 def Number: Parser[Double] =
   token(_.toDoubleOption.isDefined, "number").map(_.toDouble)
 
-def ops: Parser[String] = "+" | "-"
+def ops: Parser[String] = "+" | "-" | "*" | "/"
 
 @main def Test =
   println(Expr.parseAll("2 * ( 3 + 4 - 2 / 1 )".split(" ").toList))