Fix handling of compiletime.erasedValue

Fixes #23406

Author: odersky

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

@@ -1558,6 +1558,11 @@ class Definitions {
   @tu lazy val pureSimpleClasses =
     Set(StringClass, NothingClass, NullClass) ++ ScalaValueClasses()
 
+  @tu lazy val capsErasedValueMethods =
+    Set[Symbol]()
+  @tu lazy val erasedValueMethods =
+    capsErasedValueMethods + Compiletime_erasedValue
+
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)

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

@@ -1054,6 +1054,7 @@ object SymDenotations {
     def isEffectivelyErased(using Context): Boolean =
       isOneOf(EffectivelyErased)
       || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
+      || defn.erasedValueMethods.contains(symbol)
 
     /** Is this a member that will become public in the generated binary */
     def hasPublicInBinary(using Context): Boolean =

compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala

@@ -341,6 +341,17 @@ class InlineReducer(inliner: Inliner)(using Context):
     val scrutineeSym = newSym(InlineScrutineeName.fresh(), Synthetic, scrutType).asTerm
     val scrutineeBinding = normalizeBinding(ValDef(scrutineeSym, scrutinee))
 
+    // If scrutinee has embedded `compiletime.erasedValue[T]` expressions, convert them to
+    // mark scrutineeSym as Erased. This means that the scrutinee cannot be referenced in
+    // the reduced term. It is NOT checked that scrutinee is a pure expression, since
+    // there is a special case in Erase that exempts the RHS of an erased scrutinee definition.
+    if scrutinee.existsSubTree:
+      case tree @ TypeApply(fn, args) => tree.symbol == defn.Compiletime_erasedValue
+      case _ => false
+    then
+      scrutineeSym.setFlag(Erased)
+
+
     def reduceCase(cdef: CaseDef): MatchReduxWithGuard = {
       val caseBindingMap = new mutable.ListBuffer[(Symbol, MemberDef)]()
 

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

@@ -2950,14 +2950,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     EmptyTree
 
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = if !sym.info.exists then retractDefDef(sym) else ctx.profiler.onTypedDef(sym) {
-
-    // TODO: - Remove this when `scala.language.experimental.erasedDefinitions` is no longer experimental.
-    //       - Modify signature to `erased def erasedValue[T]: T`
-    if sym.eq(defn.Compiletime_erasedValue) then
-      // scala.compiletime.erasedValue should be `erased` but we cannot add this in the source.
-      // The library cannot use experimental language features,
-      // hence we special case it until `erased` is no longer experimental.
-      sym.setFlag(Erased)
     val DefDef(name, paramss, tpt, _) = ddef
     checkNonRootName(ddef.name, ddef.nameSpan)
     completeAnnotations(ddef, sym)

library/src/scala/compiletime/package.scala

@@ -23,7 +23,6 @@ import annotation.{compileTimeOnly, experimental}
  *  the branches.
  *  @syntax markdown
  */
-// TODO add `erased` once it is not an experimental feature anymore
 def erasedValue[T]: T = erasedValue[T]
 
 /** Used as the initializer of a mutable class or object field, like this:

tests/neg/i23406.scala

@@ -0,0 +1,5 @@
+inline def funny[T]: String =
+  inline compiletime.erasedValue[T] match
+    case x: String => x
+
+@main def Test = funny[String]  // error

tests/pending/neg/erased-impure.check

@@ -0,0 +1,44 @@
+//> using options -explain
+import language.experimental.erasedDefinitions
+import java.io.IOException
+import caps.unsafe.unsafeErasedValue
+
+class CanThrow[-E <: Exception]
+
+def foo[E <: Exception](e: E)(using erased CanThrow[E]): Nothing = throw e
+
+erased val magic1: IOException = ???  // error
+erased val magic2: IOException = compiletime.erasedValue[IOException]  // error
+erased val magic3: IOException = null.asInstanceOf[IOException]  // error
+
+inline def inlineId[T](x: T) = x
+
+class C()
+
+def testPure[T](erased x: T): Unit = ()
+
+case class Pair[A, B](x: A, y: B)
+object Pair:
+  def apply(x: Int): Pair2[Int, Int] =
+    println("Pair2")
+    Pair2(x, x + 1)
+
+case class Box[A](x: A):
+  println(x)
+
+def Test =
+  foo(new IOException)(using ???)  // error
+  foo(new IOException)(using inlineId(???))  // error
+
+  testPure(C()) // OK
+  testPure(inlineId(C())) // OK
+  testPure(identity(C())) // error, identity is not an inline function
+
+  testPure(Pair(unsafeErasedValue[Int], unsafeErasedValue[String])) // OK
+  testPure(Pair(unsafeErasedValue[Int])) // error
+  testPure(Box(unsafeErasedValue[Int])) // error
+
+
+
+
+