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,26 @@ 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) =>
+            def defaultMsg =
+              s"""Reference to ${tree.symbol.showLocated} should not have survived,
+                 |it should have been processed and eliminated during expansion of an enclosing macro or term erasure."""
+            if (ctx.scala2Mode) {
+              // Scala 2 macros cannot be expanded for which we emit warnings. The best we can do is warn as well.
+              ctx.warning(defaultMsg, tree.sourcePos)
+            } else {
+              annot.tree match {
+                case Apply(_, Literal(msg) :: Nil) => ctx.error(msg.stringValue, tree.sourcePos)
+                case _ => ctx.error(defaultMsg, tree.sourcePos)
+              }
+            }
+          case _ => // OK
+        }
+      }
       tree
     }
 

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

@@ -401,8 +401,6 @@ 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)
     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/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -822,16 +822,6 @@ object RefChecks {
         case _ =>
       }
     }
-    /*  (Not enabled yet)
-       *  See an explanation of compileTimeOnly in its scaladoc at scala.annotation.compileTimeOnly.
-       *
-      if (sym.isCompileTimeOnly) {
-        def defaultMsg =
-          sm"""Reference to ${sym.fullLocationString} should not have survived past type checking,
-              |it should have been processed and eliminated during expansion of an enclosing macro."""
-        // The getOrElse part should never happen, it's just here as a backstop.
-        ctx.error(sym.compileTimeOnlyMessage getOrElse defaultMsg, pos)
-      }*/
   }
 
   /** Check that a deprecated val or def does not override a

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