Pre-check modifiers in Parsers

Adapted from #5525: Check that only access modifiers are legal for enums
(both definitions and cases). This is useful as a pre-check, to avoid confusing
error messages later.

Author: odersky

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -288,7 +288,7 @@ object DesugarEnums {
       val toStringDef = toStringMethLit(name.toString)
       val impl1 = cpy.Template(impl)(body = List(ordinalDef, toStringDef) ++ registerCall)
         .withAttachment(ExtendsSingletonMirror, ())
-      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | EnumValue)
+      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }
   }
@@ -304,7 +304,7 @@ object DesugarEnums {
     else {
       val (tag, scaffolding) = nextOrdinal(CaseKind.Simple)
       val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
-      val vdef = ValDef(name, enumClassRef, creator).withMods(mods | EnumValue)
+      val vdef = ValDef(name, enumClassRef, creator).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(scaffolding ::: vdef :: Nil).withSpan(span)
     }
 }

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

@@ -3330,22 +3330,29 @@ object Parsers {
       }
     }
 
+    private def checkAccessOnly(mods: Modifiers, where: String): Modifiers =
+      val mods1 = mods & (AccessFlags | Enum)
+      if mods1 ne mods then
+        syntaxError(s"Only access modifiers are allowed on enum $where")
+      mods1
+
     /**  EnumDef ::=  id ClassConstr InheritClauses [‘with’] EnumBody
      */
     def enumDef(start: Offset, mods: Modifiers): TypeDef = atSpan(start, nameStart) {
+      val mods1 = checkAccessOnly(mods, "definitions")
       val modulName = ident()
       in.endMarkerScope(modulName) {
         val clsName = modulName.toTypeName
         val constr = classConstr()
         val templ = template(constr, isEnum = true)
-        finalizeDef(TypeDef(clsName, templ), mods, start)
+        finalizeDef(TypeDef(clsName, templ), mods1, start)
       }
     }
 
     /** EnumCase = `case' (id ClassConstr [`extends' ConstrApps] | ids)
      */
     def enumCase(start: Offset, mods: Modifiers): DefTree = {
-      val mods1 = mods | EnumCase
+      val mods1 = checkAccessOnly(mods, "cases") | EnumCase
       accept(CASE)
 
       atSpan(start, nameStart) {

tests/neg/i5525.scala

@@ -0,0 +1,37 @@
+abstract enum Foo1 {} // error: only access modifiers allowed
+final    enum Foo2 {} // error: only access modifiers allowed
+sealed   enum Foo3 {} // error: only access modifiers allowed
+implicit enum Foo4 {} // error: only access modifiers allowed
+lazy     enum Foo5 {} // error: only access modifiers allowed
+erased   enum Foo6 {} // error: only access modifiers allowed
+override enum Foo7 {} // error: only access modifiers allowed
+inline   enum Foo8 {} // error: only access modifiers allowed
+opaque   enum Foo9 {} // error: only access modifiers allowed
+
+enum Foo10 {
+  abstract  case C1()  // error: only access modifiers allowed
+  final     case C2()  // error: only access modifiers allowed
+  sealed    case C3()  // error: only access modifiers allowed
+  implicit  case C4()  // error: only access modifiers allowed
+  lazy      case C5()  // error: only access modifiers allowed
+  erased    case C6()  // error: only access modifiers allowed
+  override  case C7()  // error: only access modifiers allowed
+  private   case C8()  // ok
+  protected case C9()  // ok
+}
+
+enum Foo11 {
+  abstract  case C1  // error: only access modifiers allowed
+  final     case C2  // error: only access modifiers allowed
+  sealed    case C3  // error: only access modifiers allowed
+  implicit  case C4  // error: only access modifiers allowed
+  lazy      case C5  // error: only access modifiers allowed
+  erased    case C6  // error: only access modifiers allowed
+  override  case C7  // error: only access modifiers allowed
+  private   case C8  // ok
+  protected case C9  // ok
+}
+
+enum Foo12 {  // error: enums must contain at least one case
+  inline    case C10() // error // error // error (inline treated as ident here)
+}