Fix scala#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,18 @@ 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) =>
+            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))

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -172,7 +172,7 @@ class CompilationTests extends ParallelTesting {
       "tests/neg-custom-args/toplevel-samesource/S.scala",
       "tests/neg-custom-args/toplevel-samesource/nested/S.scala"),
       defaultOptions) +
-    compileFile("tests/neg-custom-args/i6300.scala", allowDeepSubtypes)
+    compileFile("tests/neg-custom-args/i6300.scala", allowDeepSubtypes) +
     compileFile("tests/neg-custom-args/i6312.scala", defaultOptions and "-Xfatal-warnings" and "-migration")
   }.checkExpectedErrors()
 

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
+}