Disallow erased def

odersky · odersky · commit 07ce2c9d55af · 2025-07-06T17:34:12.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -681,10 +681,12 @@ object Checking {
       fail(ModifierNotAllowedForDefinition(Flags.Infix, s"A top-level ${sym.showKind} cannot be infix."))
     if sym.isUpdateMethod && !sym.owner.derivesFrom(defn.Caps_Mutable) then
       fail(em"Update methods can only be used as members of classes extending the `Mutable` trait")
-    checkApplicable(Erased,
-      !sym.is(Lazy, butNot = Given)
-      && !sym.isMutableVarOrAccessor
-      && (!sym.isType || sym.isClass))
+    val unerasable =
+      sym.is(Lazy, butNot = Given)
+      || sym.is(Method, butNot = Macro)
+      || sym.is(Mutable)
+      || sym.isType && !sym.isClass
+    checkApplicable(Erased, !unerasable)
     checkCombination(Final, Open)
     checkCombination(Sealed, Open)
     checkCombination(Final, Sealed)
diff --git a/tests/invalid/neg/erased-1.scala b/tests/invalid/neg/erased-1.scala
diff --git a/tests/invalid/neg/erased-2.scala b/tests/invalid/neg/erased-2.scala
diff --git a/tests/invalid/neg/erased-3.scala b/tests/invalid/neg/erased-3.scala
diff --git a/tests/invalid/neg/erased-args-lifted.scala b/tests/invalid/neg/erased-args-lifted.scala
@@ -2,7 +2,7 @@
 
 object Test {
   def foo(a: Int)(b: Int, c: Int) = 42
-  erased def bar(erased i: Int): Int = {
+  inline def bar(erased i: Int): Int = {
     println(1)
     42
   }
diff --git a/tests/invalid/neg/erased-implicit.scala b/tests/invalid/neg/erased-implicit.scala
diff --git a/tests/invalid/neg/erased-params.scala b/tests/invalid/neg/erased-params.scala
diff --git a/tests/invalid/pos/i11743.scala b/tests/invalid/pos/i11743.scala
@@ -2,7 +2,7 @@ import language.experimental.erasedDefinitions
 import scala.compiletime.erasedValue
 type UnivEq[A]
 object UnivEq:
-  erased def force[A]: UnivEq[A] = erasedValue
+  inline def force[A]: UnivEq[A] = erasedValue
   extension [A](erased proof: UnivEq[A])
     inline def univEq(a: A, b: A): Boolean =
       a == b
diff --git a/tests/invalid/pos/i17584a.scala b/tests/invalid/pos/i17584a.scala
diff --git a/tests/neg/erased-6.scala b/tests/neg/erased-6.scala
@@ -1,7 +1,7 @@
 //> using options -language:experimental.erasedDefinitions
 
 object Test {
-  erased def foo: Foo = new Foo
+  erased val foo: Foo = new Foo
   foo.x() // error
   foo.y // error
   foo.z // error
diff --git a/tests/neg/erased-assign.scala b/tests/neg/erased-assign.scala
@@ -4,7 +4,7 @@ object Test {
   var i: Int = 1
   def foo(erased a: Int): Int = {
     i = a // error
-    erased def r = {
+    inline def r = {
       i = a
       ()
     }
diff --git a/tests/neg/experimental-imports.scala b/tests/neg/experimental-imports.scala
@@ -8,41 +8,41 @@ object Object1:
   import language.experimental.namedTypeArguments
   import language.experimental.genericNumberLiterals
   import language.experimental.erasedDefinitions
-  erased def f = 1
+  erased val f = 1
 
 object Object2:
   import language.experimental.fewerBraces // error
   import language.experimental.namedTypeArguments // error
   import language.experimental.genericNumberLiterals // error
   import language.experimental.erasedDefinitions // error
-  erased def f = 1
+  erased val f = 1
 
 @experimental
 object Class1:
   import language.experimental.fewerBraces
   import language.experimental.namedTypeArguments
   import language.experimental.genericNumberLiterals
   import language.experimental.erasedDefinitions
-  erased def f = 1
+  erased val f = 1
 
 object Class2:
   import language.experimental.fewerBraces // error
   import language.experimental.namedTypeArguments // error
   import language.experimental.genericNumberLiterals // error
   import language.experimental.erasedDefinitions // error
-  erased def f = 1
+  erased val f = 1
 
 @experimental
 def fun1 =
   import language.experimental.fewerBraces
   import language.experimental.namedTypeArguments
   import language.experimental.genericNumberLiterals
   import language.experimental.erasedDefinitions
-  erased def f = 1
+  erased val f = 1
 
 def fun2 =
   import language.experimental.fewerBraces // error
   import language.experimental.namedTypeArguments // error
   import language.experimental.genericNumberLiterals // error
   import language.experimental.erasedDefinitions // error
-  erased def f = 1
+  erased val f = 1
diff --git a/tests/neg/experimental.scala b/tests/neg/experimental.scala
@@ -13,7 +13,7 @@ class Test1 {
   import scala.compiletime.erasedValue
   type UnivEq[A]
   object UnivEq:
-    erased def force[A]: UnivEq[A] = erasedValue
+    inline def force[A]: UnivEq[A] = erasedValue
     extension [A](erased proof: UnivEq[A])
       inline def univEq(a: A, b: A): Boolean =
         a == b
diff --git a/tests/neg/magic-canthrow.scala b/tests/neg/magic-canthrow.scala
@@ -0,0 +1,11 @@
+import language.experimental.erasedDefinitions
+import java.io.IOException
+
+class CanThrow[-E <: Exception]
+
+def foo[E <: Exception](e: E)(using erased CanThrow[E]): Nothing = throw e
+
+erased def magic[E]: E = magic  // error
+
+def Test = foo(new IOException)(using magic)
+
diff --git a/tests/neg/typeclass-derivation2.scala b/tests/neg/typeclass-derivation2.scala
@@ -119,7 +119,7 @@ object TypeLevel {
   type Subtype[t] = Type[_, t]
   type Supertype[t] = Type[t, _]
   type Exactly[t] = Type[t, t]
-  erased def typeOf[T]: Type[T, T] = compiletime.erasedValue
+  inline def typeOf[T]: Type[T, T] = compiletime.erasedValue
 }
 
 // An algebraic datatype
diff --git a/tests/new/test.scala b/tests/new/test.scala
@@ -1,15 +1,12 @@
+import java.io.IOException
 
-package foo
-
-package object bar:
-  opaque type O[X] >: X = X
-
-class Test:
-  import bar.O
-
-  val x = "abc"
-  val y: O[String] = x
-  //val z: String = y
+class CanThrow[-E <: Exception]
 
+def foo[E <: Exception](e: E)(using erased CanThrow[E]): Nothing = throw e
 
+erased def magic[E]: E = magic // error
+inline def moreMagic[E]: E = moreMagic
 
+def Test =
+  foo(new IOException)(using magic)
+  foo(new IOException)(using moreMagic) // should be error
diff --git a/tests/pos/erased-conforms.scala b/tests/pos/erased-conforms.scala
@@ -5,7 +5,7 @@ erased class <::<[-From, +To] extends ErasedTerm
 
 erased class =::=[From, To] extends (From <::< To)
 
-erased given [X] => (X =::= X) = scala.compiletime.erasedValue
+inline given [X] => (X =::= X) = scala.compiletime.erasedValue
 
 extension [From](x: From)
   inline def cast[To](using From <::< To): To = x.asInstanceOf[To] // Safe cast because we know `From <:< To`
diff --git a/tests/pos/expeimental-flag-with-lang-feature.scala b/tests/pos/expeimental-flag-with-lang-feature.scala
diff --git a/tests/pos/experimental-imports-top.scala b/tests/pos/experimental-imports-top.scala
@@ -4,4 +4,4 @@ import language.experimental.erasedDefinitions
 import annotation.experimental
 
 @experimental
-erased def f = 1
+erased val f = 1
diff --git a/tests/pos/experimentalErased.scala b/tests/pos/experimentalErased.scala
@@ -6,11 +6,6 @@ erased class Foo
 
 erased class Bar
 
-@experimental
-erased def foo = 2
-
-erased def bar = 2
-
 @experimental
 erased val foo2 = 2
 
diff --git a/tests/pos/i11864.scala b/tests/pos/i11864.scala
@@ -40,7 +40,7 @@ final class CallbackTo[+A] {
 object CallbackTo {
 
   type MapGuard[A] = { type Out = A }
-  erased given MapGuard: [A] => MapGuard[A] = compiletime.erasedValue
+  inline given MapGuard: [A] => MapGuard[A] = compiletime.erasedValue
 
   def traverse[A, B](ta: List[A]): CallbackTo[List[B]] =
     val x: CallbackTo[List[A] => List[B]] = ???
diff --git a/tests/pos/i11896.scala b/tests/pos/i11896.scala
@@ -1,7 +1,7 @@
 import scala.language.experimental.erasedDefinitions
 
 type X
-erased def x: X = compiletime.erasedValue
+inline def x: X = compiletime.erasedValue
 
 def foo(using erased X): Unit = ()
 
diff --git a/tests/pos/i6419.scala b/tests/pos/i6419.scala
@@ -9,8 +9,4 @@ class Foo {
   inline def bar: Unit = {
     foo
   }
-
-  erased def baz: Unit = {
-    foo
-  }
 }
diff --git a/tests/pos/i7741.scala b/tests/pos/i7741.scala
@@ -3,9 +3,6 @@ import scala.language.experimental.erasedDefinitions
 class A1 {
     @native private def a: Unit
 }
-trait A2 {
-    erased def i(erased a: Int): Int
-}
 trait A3 {
     erased val a: Int
 }
diff --git a/tests/pos/inline-match-gadt.scala b/tests/pos/inline-match-gadt.scala
@@ -2,7 +2,7 @@ import scala.language.experimental.erasedDefinitions
 
 object `inline-match-gadt` {
   class Exactly[T]
-  erased def exactType[T]: Exactly[T] = compiletime.erasedValue
+  inline def exactType[T]: Exactly[T] = compiletime.erasedValue
 
   inline def foo[T](t: T): T =
     inline exactType[T] match {
diff --git a/tests/pos/phantom-Eq.scala b/tests/pos/phantom-Eq.scala
@@ -16,18 +16,19 @@ object PhantomEq {
 
 object EqUtil {
 
-  type PhantomEq[-L, -R]
+  class PhantomEq[-L, -R]
   type PhantomEqEq[T] = PhantomEq[T, T]
+  erased val phantomEq = PhantomEq[Any, Any]()
 
   extension [T](x: T)
     def ===[U](y: U)(using erased PhantomEq[T, U]) = x.equals(y)
 
-  erased given eqString: PhantomEqEq[String] = compiletime.erasedValue
-  erased given eqInt: PhantomEqEq[Int]       = compiletime.erasedValue
-  erased given eqDouble: PhantomEqEq[Double] = compiletime.erasedValue
+  inline given eqString: PhantomEqEq[String] = phantomEq
+  inline given eqInt: PhantomEqEq[Int]       = phantomEq
+  inline given eqDouble: PhantomEqEq[Double] = phantomEq
 
-  erased given eqByteNum: PhantomEq[Byte, Number] = compiletime.erasedValue
-  erased given eqNumByte: PhantomEq[Number, Byte] = compiletime.erasedValue
+  inline given eqByteNum: PhantomEq[Byte, Number] = phantomEq
+  inline given eqNumByte: PhantomEq[Number, Byte] = phantomEq
 
-  erased given eqSeq: [T, U] => (erased PhantomEq[T, U]) => PhantomEq[Seq[T], Seq[U]] = compiletime.erasedValue
+  inline given eqSeq: [T, U] => (erased PhantomEq[T, U]) => PhantomEq[Seq[T], Seq[U]] = phantomEq
 }
diff --git a/tests/pos/phantom-Eq2/Phantom-Eq_1.scala b/tests/pos/phantom-Eq2/Phantom-Eq_1.scala
@@ -1,19 +1,20 @@
 import scala.language.experimental.erasedDefinitions
+import scala.annotation.publicInBinary
 
 /* This is a version of ../pos/phantomEq.scala that tests phantom with separate compilation */
 object EqUtil {
 
-  final class PhantomEq[-L, -R] private[EqUtil]()
+  final class PhantomEq[-L, -R] @publicInBinary private[EqUtil]()
   type PhantomEqEq[T] = PhantomEq[T, T]
 
   extension [T](x: T)
     def ===[U] (y: U) (using erased PhantomEq[T, U]) = x.equals(y)
 
-  erased given eqString: PhantomEqEq[String] = new PhantomEq[String, String]
-  erased given eqInt: PhantomEqEq[Int]       = new PhantomEq[Int, Int]
-  erased given eqDouble: PhantomEqEq[Double] = new PhantomEq[Double, Double]
-  erased given eqByteNum: PhantomEq[Byte, Number] = new PhantomEq[Byte, Number]
-  erased given eqNumByte: PhantomEq[Number, Byte] = new PhantomEq[Number, Byte]
-  erased given eqSeq: [T, U] => (erased eq: PhantomEq[T, U]) => PhantomEq[Seq[T], Seq[U]] =
+  inline given eqString: PhantomEqEq[String] = new PhantomEq[String, String]
+  inline given eqInt: PhantomEqEq[Int]       = new PhantomEq[Int, Int]
+  inline given eqDouble: PhantomEqEq[Double] = new PhantomEq[Double, Double]
+  inline given eqByteNum: PhantomEq[Byte, Number] = new PhantomEq[Byte, Number]
+  inline given eqNumByte: PhantomEq[Number, Byte] = new PhantomEq[Number, Byte]
+  inline given eqSeq: [T, U] => (erased eq: PhantomEq[T, U]) => PhantomEq[Seq[T], Seq[U]] =
     new PhantomEq[Seq[T], Seq[U]]
 }
diff --git a/tests/pos/phantom-Evidence.scala b/tests/pos/phantom-Evidence.scala
@@ -26,5 +26,5 @@ object WithNormalState {
 
 object Utils {
   type =::=[From, To]
-  erased given tpEquals: [A] => (A =::= A) = compiletime.erasedValue
+  inline given tpEquals: [A] => (A =::= A) = compiletime.erasedValue
 }
diff --git a/tests/run/erased-10.scala b/tests/run/erased-10.scala
@@ -10,7 +10,7 @@ object Test {
     println("pacFun4")
   }
 
-  erased def inky: Int = {
+  inline def inky: Int = {
     println("inky") // in erased function
     42
   }
diff --git a/tests/run/erased-select-prefix.scala b/tests/run/erased-select-prefix.scala
@@ -29,9 +29,9 @@ object Test {
 
   def bar(erased i: Int): Unit = ()
 
-  erased def foo0: Int = 0
-  erased def foo1(): Int = 1
-  erased def foo2[T]: Int = 2
-  erased def foo3[T](): Int = 3
+  inline def foo0: Int = 0
+  inline def foo1(): Int = 1
+  inline def foo2[T]: Int = 2
+  inline def foo3[T](): Int = 3
 
 }
diff --git a/tests/run/i11996.scala b/tests/run/i11996.scala
@@ -3,7 +3,7 @@
 final class UnivEq[A]
 
 object UnivEq:
-  erased def force[A]: UnivEq[A] =
+  inline def force[A]: UnivEq[A] =
     compiletime.erasedValue
 
 extension [A](a: A)

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`object Test {`
`4`	`4`	`def foo(a: Int)(b: Int, c: Int) = 42`
`5`		`- erased def bar(erased i: Int): Int = {`
	`5`	`+ inline def bar(erased i: Int): Int = {`
`6`	`6`	`println(1)`
`7`	`7`	`42`
`8`	`8`	`}`