Require erased values to be pure expressions

Author: odersky

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -228,6 +228,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case OnlyFullyDependentAppliedConstructorTypeID // errorNumber: 212
   case PointlessAppliedConstructorTypeID // errorNumber: 213
   case IllegalContextBoundsID // errorNumber: 214
+  case ErasedNotPureID // errornumber 215
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3535,3 +3535,35 @@ final class IllegalContextBounds(using Context) extends SyntaxMsg(IllegalContext
   override protected def explain(using Context): String = ""
 
 end IllegalContextBounds
+
+final class ErasedNotPure(tree: tpd.Tree, isArgument: Boolean, isImplicit: Boolean)(using Context) extends TypeMsg(ErasedNotPureID):
+  def what =
+    if isArgument then s"${if isImplicit then "implicit " else ""}argument to an erased parameter"
+    else "right-hand-side of an erased value"
+  override protected def msg(using Context): String =
+    i"$what fails to be a pure expression"
+
+  override protected def explain(using Context): String =
+    def alternatives =
+      if tree.symbol == defn.Compiletime_erasedValue then
+        i"""An accepted (but unsafe) alternative for this expression uses function
+           |
+           |      caps.unsafe.unsafeErasedValue
+           |
+           |instead."""
+      else
+        """A pure expression is an expression that is clearly side-effect free and terminating.
+          |Some examples of pure expressions are:
+          |  - literals,
+          |  - references to values,
+          |  - side-effect-free instance creations,
+          |  - applications of inline functions to pure arguments."""
+
+    i"""The $what must be a pure expression, but I found:
+       |
+       |  $tree
+       |
+       |This expression is not classified to be pure.
+       |$alternatives"""
+end ErasedNotPure
+

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

@@ -14,7 +14,7 @@ import core.Names.*
 import core.StdNames.*
 import core.NameOps.*
 import core.Periods.currentStablePeriod
-import core.NameKinds.{AdaptedClosureName, BodyRetainerName, DirectMethName}
+import core.NameKinds.{AdaptedClosureName, BodyRetainerName, DirectMethName, InlineScrutineeName}
 import core.Scopes.newScopeWith
 import core.Decorators.*
 import core.Constants.*
@@ -583,16 +583,11 @@ object Erasure {
       checkNotErasedClass(tree)
     end checkNotErased
 
-    def checkPureErased(tree: untpd.Tree, isArgument: Boolean)(using Context): Unit =
-      if false then inContext(preErasureCtx):
-        if tpd.isPureExpr(tree.asInstanceOf[tpd.Tree]) then
-          val tree1 = tree.asInstanceOf[tpd.Tree]
-          println(i"$tree1 is pure, ${tree1.tpe.widen}")
-        else
-          def what =
-            if isArgument then "argument to erased parameter"
-            else "right-hand-side of erased value"
-          report.error(em"$what fails to be a pure expression", tree.srcPos)
+    def checkPureErased(tree: untpd.Tree, isArgument: Boolean, isImplicit: Boolean = false)(using Context): Unit =
+      val tree1 = tree.asInstanceOf[tpd.Tree]
+      inContext(preErasureCtx):
+        if !tpd.isPureExpr(tree1) then
+          report.error(ErasedNotPure(tree1, isArgument, isImplicit), tree1.srcPos)
 
     private def checkNotErasedClass(tp: Type, tree: untpd.Tree)(using Context): Unit = tp match
       case JavaArrayType(et) =>
@@ -861,7 +856,8 @@ object Erasure {
         case mt: MethodType if mt.hasErasedParams =>
           args.lazyZip(mt.paramErasureStatuses).flatMap: (arg, isErased) =>
             if isErased then
-              checkPureErased(arg, isArgument = true)
+              checkPureErased(arg, isArgument = true,
+                isImplicit = mt.isImplicitMethod && arg.span.isSynthetic)
               Nil
             else
               arg :: Nil
@@ -933,9 +929,10 @@ object Erasure {
 
     override def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree =
       if sym.isEffectivelyErased then
-        checkPureErased(vdef.rhs, isArgument = false)
+        if !sym.name.is(InlineScrutineeName) then
+          checkPureErased(vdef.rhs, isArgument = false)
         erasedDef(sym)
-      else
+      else trace(i"erasing $vdef"):
         checkNotErasedClass(sym.info, vdef)
         super.typedValDef(untpd.cpy.ValDef(vdef)(
           tpt = untpd.TypedSplice(TypeTree(sym.info).withSpan(vdef.tpt.span))), sym)
@@ -946,7 +943,6 @@ object Erasure {
      */
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree =
       if sym.isEffectivelyErased || sym.name.is(BodyRetainerName) then
-        checkPureErased(ddef.rhs, isArgument = false)
         erasedDef(sym)
       else
         checkNotErasedClass(sym.info.finalResultType, ddef)

library/src/scala/CanThrow.scala

@@ -12,5 +12,5 @@ erased class CanThrow[-E <: Exception] extends caps.SharedCapability
 
 @experimental
 object unsafeExceptions:
-  inline given canThrowAny: CanThrow[Exception] = compiletime.erasedValue
+  inline given canThrowAny: CanThrow[Exception] = caps.unsafe.unsafeErasedValue
 

tests/run/erased-1.check renamed to tests/invalid/run/erased-1.check

@@ -28,7 +28,7 @@ trait Dataset[T] {
   // Use c.label to do an untyped select on actual Spark Dataset, and
   // cast the result to TypedDataset[A]
 
-  def col[S <: String, A](s: S) (using erased ev: Exists[T, s.type, A]) =
+  inline def col[S <: String, A](s: S) (using erased ev: Exists[T, s.type, A]) =
     new Column[T, A](s) // ev is only here to check than this is safe, it's never used at runtime!
 
   def collect(): Vector[T]
@@ -71,17 +71,17 @@ case class Column[T, A](label: String)
 trait Exists[T, K, V]
 
 object Exists {
-  implicit def derive[T, H <: HList, K, V](implicit g: LabelledGeneric[T] { type Repr = H }, s: Selector[H, K, V]): Exists[T, K, V] = {
+  inline implicit def derive[T, H <: HList, K, V](implicit g: LabelledGeneric[T] { type Repr = H }, s: Selector[H, K, V]): Exists[T, K, V] = {
     println("Exists.derive")
     null
   }
 
-  implicit def caseFound[T <: HList, K <: String, V]: Selector[R[K, V] :: T, K, V] = {
+  inline implicit def caseFound[T <: HList, K <: String, V]: Selector[R[K, V] :: T, K, V] = {
     println("Selector.caseFound")
     null
   }
 
-  implicit def caseRecur[H, T <: HList, K <: String, V](implicit i: Selector[T, K, V]): Selector[H :: T, K, V] = {
+  inline implicit def caseRecur[H, T <: HList, K <: String, V](implicit i: Selector[T, K, V]): Selector[H :: T, K, V] = {
     println("Selector.caseRecur")
     null
   }

tests/run/erased-1.scala renamed to tests/invalid/run/erased-1.scala

@@ -1,7 +1,7 @@
 //> using options -language:experimental.erasedDefinitions
 
 object Test {
-  erased val foo: Foo = new Foo
+  erased val foo: Foo = new Foo  // error, Foo is not noInits
   foo.x() // error
   foo.y // error
   foo.z // error

tests/run/erased-10.check renamed to tests/invalid/run/erased-10.check

@@ -4,7 +4,7 @@ erased class AA
 erased class BB extends AA // ok
 
 @main def Test =
-  val f1: Array[AA] = compiletime.erasedValue // error // error
-  def f2(x: Int): Array[AA] = compiletime.erasedValue // error // error
-  def bar: AA = compiletime.erasedValue  // ok
-  val baz: AA = compiletime.erasedValue // ok
+  val f1: Array[AA] = caps.unsafe.unsafeErasedValue // error // error
+  def f2(x: Int): Array[AA] = caps.unsafe.unsafeErasedValue // error // error
+  def bar: AA = caps.unsafe.unsafeErasedValue  // ok
+  val baz: AA = caps.unsafe.unsafeErasedValue // ok

tests/run/erased-10.scala renamed to tests/invalid/run/erased-10.scala

@@ -0,0 +1,10 @@
+-- Error: tests/neg/erasedValueb.scala:7:7 -----------------------------------------------------------------------------
+7 |  foo0(erasedValue[Int]) // error
+  |       ^^^^^^^^^^^
+  |       method erasedValue is declared as `erased`, but is in fact used
+-- [E215] Type Error: tests/neg/erasedValueb.scala:8:18 ----------------------------------------------------------------
+8 |  foo1(erasedValue[Int]) // error
+  |       ^^^^^^^^^^^^^^^^
+  |       argument to an erased parameter fails to be a pure expression
+  |
+  | longer explanation available when compiling with `-explain`

tests/run/erased-11.check renamed to tests/invalid/run/erased-11.check

@@ -5,5 +5,5 @@ object Test {
   def foo0(a: Int): Int = 3
   def foo1(erased a: Int): Int = 3
   foo0(erasedValue[Int]) // error
-  foo1(erasedValue[Int])
+  foo1(erasedValue[Int]) // error
 }

tests/run/erased-11.scala renamed to tests/invalid/run/erased-11.scala

@@ -14,7 +14,7 @@ def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
 def handle[E <: Exception, R](op: (erased CanThrow[E]) -> R)(handler: E -> R): R =
-  erased val x: CanThrow[E] = ??? : CanThrow[E]
+  erased val x = caps.unsafe.unsafeErasedValue[CanThrow[E]]
   try op(x)
   catch case ex: E => handler(ex)
 

tests/run/erased-12.check renamed to tests/invalid/run/erased-12.check

@@ -11,7 +11,7 @@ object Test {
 
     val ds: Dataset = ???
 
-    lazy val collD = new Column
+    val collD = new Column
 
     ds.select(collD)
 

tests/run/erased-12.scala renamed to tests/invalid/run/erased-12.scala

@@ -5,7 +5,7 @@ erased class <::<[-From, +To] extends ErasedTerm
 
 erased class =::=[From, To] extends (From <::< To)
 
-inline given [X] => (X =::= X) = scala.compiletime.erasedValue
+inline given [X] => (X =::= X) = scala.caps.unsafe.unsafeErasedValue
 
 extension [From](x: From)
   inline def cast[To](using From <::< To): To = x.asInstanceOf[To] // Safe cast because we know `From <:< To`

tests/run/erased-13.check renamed to tests/invalid/run/erased-13.check

@@ -1,4 +1,5 @@
 import language.experimental.erasedDefinitions
+import caps.unsafe.unsafeErasedValue
 
 inline def id[T](x: T) = x
 
@@ -8,6 +9,7 @@ def foo[T](erased x: T): Unit = ()
 
 class Pair[A, B](x: A, y: B)
 
+case class Pair2[A, B](x: A, y: B)
 
 def Test =
   foo(C())
@@ -17,7 +19,8 @@ def Test =
   foo(Pair(C(), "hello" + "world"))
   foo(id(Pair(id(C()), id("hello" + "world"))))
 
-
-
+  //erased val x1 = Pair(unsafeErasedValue[Int], unsafeErasedValue[String])
+  //erased val x2 = Pair2(unsafeErasedValue[Int], unsafeErasedValue[String])
+  erased val x3 = Tuple2(unsafeErasedValue[Int], unsafeErasedValue[String])
 
 

tests/run/erased-13.scala renamed to tests/invalid/run/erased-13.scala

@@ -40,7 +40,7 @@ final class CallbackTo[+A] {
 object CallbackTo {
 
   type MapGuard[A] = { type Out = A }
-  inline given MapGuard: [A] => MapGuard[A] = compiletime.erasedValue
+  inline given MapGuard: [A] => MapGuard[A] = caps.unsafe.unsafeErasedValue
 
   def traverse[A, B](ta: List[A]): CallbackTo[List[B]] =
     val x: CallbackTo[List[A] => List[B]] = ???

tests/run/erased-14.check renamed to tests/invalid/run/erased-14.check

@@ -1,7 +1,7 @@
 import scala.language.experimental.erasedDefinitions
 
 type X
-inline def x: X = compiletime.erasedValue
+inline def x: X = caps.unsafe.unsafeErasedValue
 
 def foo(using erased X): Unit = ()
 

tests/run/erased-14.scala renamed to tests/invalid/run/erased-14.scala

@@ -1,7 +1,6 @@
 import scala.language.experimental.erasedDefinitions
 
 import compiletime.summonFrom
-import compiletime.erasedValue
 
 trait Link[T, A]
 
@@ -15,7 +14,7 @@ transparent inline def link[T] =
 
 class Foo
 object Foo {
-  erased implicit val barLink: Link[Foo, Bar.type] = erasedValue
+  erased implicit val barLink: Link[Foo, Bar.type] = caps.unsafe.unsafeErasedValue
 }
 
 implicit object Bar {

tests/run/erased-16.check renamed to tests/invalid/run/erased-16.check

@@ -1,5 +1,5 @@
 import scala.language.experimental.erasedDefinitions
-import compiletime.erasedValue
+import caps.unsafe.unsafeErasedValue as erasedValue
 import compiletime.ops.int.S
 object Test {
   type T[X] = X match {

tests/run/erased-16.scala renamed to tests/invalid/run/erased-16.scala

@@ -1,4 +1,5 @@
 import scala.language.experimental.erasedDefinitions
+import annotation.publicInBinary
 
 /** In this implementation variant of =:= (called =::=) we erase all instantiations and definitions of =::= */
 object WithNormalState {
@@ -11,9 +12,9 @@ object WithNormalState {
   object Instance {
     def newInstance(): Instance[Off] = new Instance[Off]
   }
-  class Instance[S <: State] private {
-    def getOnInstance (using erased ev: S =::= Off): Instance[On] = new Instance[On] // phantom parameter ev is erased
-    def getOffInstance (using erased ev: S =::= On): Instance[Off] = new Instance[Off] // phantom parameter ev is erased
+  class Instance[S <: State] @publicInBinary private {
+    inline def getOnInstance (using erased ev: S =::= Off): Instance[On] = new Instance[On] // phantom parameter ev is erased
+    inline def getOffInstance (using erased ev: S =::= On): Instance[Off] = new Instance[Off] // phantom parameter ev is erased
   }
 
   def run() = {
@@ -26,5 +27,5 @@ object WithNormalState {
 
 object Utils {
   type =::=[From, To]
-  inline given tpEquals: [A] => (A =::= A) = compiletime.erasedValue
+  inline given tpEquals: [A] => (A =::= A) = caps.unsafe.unsafeErasedValue
 }

tests/run/erased-17.check renamed to tests/invalid/run/erased-17.check

@@ -11,8 +11,8 @@ object Test {
     )(foo)
   }
 
-  def foo = {
-    println("foo")
+  inline def foo = {
+    //println("foo")
     42
   }
 }

tests/run/erased-17.scala renamed to tests/invalid/run/erased-17.scala

@@ -9,17 +9,15 @@ final class Off extends State
 @implicitNotFound("State must be Off")
 class IsOff[S <: State]
 object IsOff {
-  implicit def isOff: IsOff[Off] = {
-    println("isOff")
+  inline implicit def isOff: IsOff[Off] = {
     new IsOff[Off]
   }
 }
 
 @implicitNotFound("State must be On")
 class IsOn[S <: State]
 object IsOn {
-  implicit def isOn: IsOn[On] = {
-    println("isOn")
+  inline implicit def isOn: IsOn[On] = {
     new IsOn[On]
   }
 }

tests/run/erased-22.check renamed to tests/invalid/run/erased-22.check

@@ -8,10 +8,9 @@ object Test {
 
   def fun(erased a: Int): Unit = println("fun")
 
-  def foo[P](erased x: Int)(erased y: Int): Int = 0
+  inline def foo[P](erased x: Int)(erased y: Int): Int = 0
 
-  def bar(x: Int) =  {
-    println(x)
+  inline def bar(x: Int) =  {
     x
   }
 }

tests/run/erased-22.scala renamed to tests/invalid/run/erased-22.scala

@@ -4,7 +4,7 @@ final class UnivEq[A]
 
 object UnivEq:
   inline def force[A]: UnivEq[A] =
-    compiletime.erasedValue
+    caps.unsafe.unsafeErasedValue
 
 extension [A](a: A)
   inline def ==*[B >: A](b: B)(using erased UnivEq[B]): Boolean = a == b