Fix #6419: Support @compileTimeOnly

Author: nicolasstucki

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

@@ -858,7 +858,7 @@ class Definitions {
   lazy val TransientParamAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.constructorOnly")
   def TransientParamAnnot(implicit ctx: Context): ClassSymbol = TransientParamAnnotType.symbol.asClass
   lazy val CompileTimeOnlyAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.compileTimeOnly")
-  def CompileTimeOnlyParamAnnot(implicit ctx: Context): ClassSymbol = CompileTimeOnlyAnnotType.symbol.asClass
+  def CompileTimeOnlyAnnot(implicit ctx: Context): ClassSymbol = CompileTimeOnlyAnnotType.symbol.asClass
   lazy val SwitchAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.switch")
   def SwitchAnnot(implicit ctx: Context): ClassSymbol = SwitchAnnotType.symbol.asClass
   lazy val ThrowsAnnotType: TypeRef = ctx.requiredClassRef("scala.throws")

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

@@ -326,8 +326,23 @@ object Erasure {
     }
 
     private def checkNotErased(tree: Tree)(implicit ctx: Context): tree.type = {
-      if (isErased(tree) && !ctx.mode.is(Mode.Type))
-        ctx.error(em"${tree.symbol} is declared as erased, but is in fact used", tree.sourcePos)
+      if (!ctx.mode.is(Mode.Type)) {
+        if (isErased(tree))
+          ctx.error(em"${tree.symbol} is declared as erased, but is in fact used", tree.sourcePos)
+        tree.symbol.getAnnotation(defn.CompileTimeOnlyAnnot) match {
+          case Some(annot) =>
+            if (ctx.scala2Mode) {
+              // Scala 2 macros cannot be expanded for which we emit warnings. The best we can do is warn as well.
+              ctx.error("Reference to member with @compileTimeOnly", tree.sourcePos)
+            } else {
+              annot.tree match {
+                case Apply(_, Literal(msg) :: Nil) => ctx.error(msg.stringValue, tree.sourcePos)
+                case _ => ctx.error("Reference to member with @compileTimeOnly", tree.sourcePos)
+              }
+            }
+          case _ => // OK
+        }
+      }
       tree
     }
 

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

@@ -401,8 +401,8 @@ object Checking {
       if (!sym.is(Deferred))
         fail(NativeMembersMayNotHaveImplementation(sym))
     }
-    if (sym.hasAnnotation(defn.CompileTimeOnlyParamAnnot))
-      ctx.migrationWarning("`@compileTimeOnly(msg)` will be replaced by `scala.compiletime.error(msg)`", sym.sourcePos)
+    if (sym.hasAnnotation(defn.CompileTimeOnlyAnnot))
+      ctx.migrationWarning("`@compileTimeOnly(msg)` should be replaced with `scala.compiletime.error(msg)`", sym.sourcePos)
     else if (sym.is(Deferred, butNot = Param) && !sym.isType && !sym.isSelfSym) {
       if (!sym.owner.isClass || sym.owner.is(Module) || sym.owner.isAnonymousClass)
         fail(OnlyClassesCanHaveDeclaredButUndefinedMembers(sym))

tests/neg/i6419.scala

@@ -0,0 +1,12 @@
+trait A {
+  @scala.annotation.compileTimeOnly("oops") def f: Int
+}
+
+class B extends A {
+  def f = 0
+}
+
+object App {
+  (new B).f
+  (new B: A).f // error
+}

tests/neg/i6419b.scala

@@ -0,0 +1,12 @@
+trait A {
+  inline def f: Int = scala.compiletime.error("oops")
+}
+
+class B extends A {
+  override def f = 0
+}
+
+object App {
+  (new B).f
+  (new B: A).f // error
+}