Flag lazy erased vals as errors

But erased givens are OK since they don't get the lazy flag set.

Author: odersky

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

@@ -529,11 +529,11 @@ object Flags {
   val RetainedModuleValAndClassFlags: FlagSet =
     AccessFlags | Package | Case |
     Synthetic | JavaDefined | JavaStatic | Artifact |
-    Lifted | MixedIn | Specialized | PhantomSymbol | Invisible | Erased
+    Lifted | MixedIn | Specialized | PhantomSymbol | Invisible
 
   /** Flags that can apply to a module val */
   val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
-    Override | Final | Method | Implicit | Given | Lazy |
+    Override | Final | Method | Implicit | Given | Lazy | Erased |
     Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Transparent
 
   /** Flags that can apply to a module class */

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -4374,7 +4374,7 @@ object Parsers {
           accept(EQUALS)
           mods1 |= Final
           if !hasParams && !mods.is(Inline) then
-            mods1 |= Lazy
+            if !mods.is(Erased) then mods1 |= Lazy
             ValDef(name, parents.head, subExpr())
           else
             DefDef(name, adjustDefParams(joinParams(tparams, vparamss)), parents.head, subExpr())

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

@@ -230,7 +230,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case IllegalContextBoundsID // errorNumber: 214
   case NamedPatternNotApplicableID // errorNumber: 215
   case UnnecessaryNN // errorNumber: 216
-  case ErasedNotPureID // errornumber 217
+  case ErasedNotPureID // errorNumber: 217
+  case IllegalErasedDefID // errorNumber: 218
 
   def errorNumber = ordinal - 1
 

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

@@ -2824,7 +2824,7 @@ class AnonymousInstanceCannotBeEmpty(impl:  untpd.Template)(using Context)
         |"""
 }
 
-class ModifierNotAllowedForDefinition(flag: Flag, explanation: String = "")(using Context)
+class ModifierNotAllowedForDefinition(flag: Flag, explanation: => String = "")(using Context)
   extends SyntaxMsg(ModifierNotAllowedForDefinitionID) {
   def msg(using Context) = i"Modifier ${hl(flag.flagsString)} is not allowed for this definition"
   def explain(using Context) = explanation
@@ -3640,3 +3640,15 @@ final class ErasedNotPure(tree: tpd.Tree, isArgument: Boolean, isImplicit: Boole
        |$alternatives"""
 end ErasedNotPure
 
+final class IllegalErasedDef(sym: Symbol)(using Context) extends TypeMsg(IllegalErasedDefID):
+  override protected def msg(using Context): String =
+    def notAllowed = "`erased` is not allowed for this kind of definition."
+    def result = if sym.is(Method) then " result" else ""
+    if sym.is(Erased) then notAllowed
+    else
+      i"""$sym is implicitly `erased` since its$result type extends trait `compiletime.Erased`.
+         |But $notAllowed"""
+
+  override protected def explain(using Context): String =
+    "Only non-lazy immutable values can be `erased`"
+end IllegalErasedDef

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

@@ -586,6 +586,12 @@ object Checking {
             |""")
   end checkScala2Implicit
 
+  def checkErasedOK(sym: Symbol)(using Context): Unit =
+    if sym.is(Method, butNot = Macro)
+        || sym.isOneOf(Mutable | Lazy)
+        || sym.isType
+    then report.error(IllegalErasedDef(sym), sym.srcPos)
+
   /** Check that symbol's definition is well-formed. */
   def checkWellFormed(sym: Symbol)(using Context): Unit = {
     def fail(msg: Message) = report.error(msg, sym.srcPos)
@@ -681,11 +687,7 @@ 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")
-    val unerasable =
-      sym.is(Method, butNot = Macro)
-      || sym.is(Mutable)
-      || sym.isType
-    checkApplicable(Erased, !unerasable)
+    if sym.is(Erased) then checkErasedOK(sym)
     checkCombination(Final, Open)
     checkCombination(Sealed, Open)
     checkCombination(Final, Sealed)

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

@@ -1911,6 +1911,7 @@ class Namer { typer: Typer =>
     mdef.tpt match
       case tpt: untpd.ContextBoundTypeTree if mbrTpe.typeSymbol == defn.SingletonClass =>
         sym.setFlag(Erased)
+        sym.resetFlag(Lazy)
       case _ =>
     if (ctx.explicitNulls && mdef.mods.is(JavaDefined))
       JavaNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))

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

@@ -2950,6 +2950,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if sym.is(Implicit) then checkImplicitConversionDefOK(sym)
     if sym.is(Module) then checkNoModuleClash(sym)
     else if sym.info.derivesFrom(defn.ErasedClass) then
+      if sym.isAllOf(Given | Lazy) && !vdef.mods.mods.exists(_.flags.is(Lazy)) then
+        // reset implied Lazy flag of givens, but keep explicit modifier
+        sym.resetFlag(Lazy)
+      checkErasedOK(sym)
       sym.setFlag(Erased)
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match
@@ -2967,6 +2971,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val nnInfo = rhs1.notNullInfo
     vdef1.withNotNullInfo(if sym.is(Lazy) then nnInfo.retractedInfo else nnInfo)
   }
+
   private def retractDefDef(sym: Symbol)(using Context): Tree =
     // it's a discarded method (synthetic case class method or synthetic java record constructor or overridden member), drop it
     val canBeInvalidated: Boolean =

tests/neg/erased-lazy-given.check

@@ -0,0 +1,7 @@
+-- [E217] Type Error: tests/neg/erased-lazy-given.scala:8:13 -----------------------------------------------------------
+8 |  lazy given E = E() // error
+  |             ^
+  |             given instance given_E is implicitly `erased` since its type extends trait `compiletime.Erased`.
+  |             But `erased` is not allowed for this kind of definition.
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg/erased-lazy-given.scala

@@ -0,0 +1,9 @@
+import language.experimental.erasedDefinitions
+
+class E extends compiletime.Erased
+
+object test1:
+  given E = E() // OK
+object test2:
+  lazy given E = E() // error
+

tests/neg/erased-lazy-val.check

@@ -0,0 +1,19 @@
+-- [E217] Type Error: tests/neg/erased-lazy-val.scala:6:18 -------------------------------------------------------------
+6 |  erased lazy val i: Int = 1 // error
+  |                  ^
+  |                  `erased` is not allowed for this kind of definition.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E217] Type Error: tests/neg/erased-lazy-val.scala:7:11 -------------------------------------------------------------
+7 |  lazy val e: E = E() // error
+  |           ^
+  |           lazy value e is implicitly `erased` since its type extends trait `compiletime.Erased`.
+  |           But `erased` is not allowed for this kind of definition.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E217] Type Error: tests/neg/erased-lazy-val.scala:8:2 --------------------------------------------------------------
+8 |  erased object obj1 // error
+  |  ^
+  |  `erased` is not allowed for this kind of definition.
+  |
+  | longer explanation available when compiling with `-explain`