Combines modifiers not allowed with type, and combinations.This also simplifies logic. Adds more detail to explanation

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

@@ -1680,21 +1680,16 @@ object Parsers {
     )
 
     def addFlag(mods: Modifiers, flag: FlagSet): Modifiers = {
-      def incompatible(kind: String) = {
-        syntaxError(ModifiersNotAllowed(mods.flags, kind))
-        Modifiers(flag)
-      }
       if (compatible(mods.flags, flag)) mods | flag
-      else flag match {
-        case Trait => incompatible("trait")
-        case Method => incompatible("method")
-        case Mutable => incompatible("variable")
-        case _ =>
-          syntaxError(s"illegal modifier combination: ${mods.flags} and $flag")
-          mods
+      else {
+        syntaxError(ModifiersNotAllowed(mods.flags, getPrintableTypeFromFlagSet(flag)))
+        Modifiers(flag)
       }
     }
 
+    private def getPrintableTypeFromFlagSet(flag: FlagSet) =
+      Map(Trait -> "trait", Method -> "method", Mutable -> "variable").get(flag)
+
     /** Always add the syntactic `mod`, but check and conditionally add semantic `mod.flags`
      */
     def addMod(mods: Modifiers, mod: Mod): Modifiers =

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

@@ -1648,18 +1648,35 @@ object messages {
     val explanation = "Method inlining prohibits calling superclass methods, as it may lead to confusion about which super is being called."
   }
 
-  case class ModifiersNotAllowed(flags: FlagSet, sort: String)(implicit ctx: Context)
+  case class ModifiersNotAllowed(flags: FlagSet, printableType: Option[String])(implicit ctx: Context)
     extends Message(ModifiersNotAllowedID) {
     val kind = "Syntax"
-    val msg = s"modifier(s) `$flags' not allowed for $sort"
+    val msg = s"modifier(s) `$flags' not allowed for ${printableType.getOrElse("combination")}"
     val explanation = {
-      val code = "sealed def y: Int = 1"
+      val first = "sealed def y: Int = 1"
+      val second = "sealed lazy class z"
       hl"""You tried to use a modifier that is inapplicable for the type of item under modification
+         |
+         |  Here is a list of modifiers and applicable item types
+         |
+         |
+         |  Modifier          ::=  LocalModifier
+         |                         AccessModifier
+         |                         `override'         traits, methods
+         |  LocalModifier     ::=  `abstract'         classes, traits
+         |                         `final'            classes, traits, methods
+         |                         `sealed'           classes, traits
+         |                         `implicit'         variables, methods, classes
+         |                         `lazy'             values
+         |  AccessModifier    ::=  (`private' | `protected') [AccessQualifier] methods, classes
+         |  AccessQualifier   ::=  `[' (id | `this') `]'
          |
          |
          |Consider the following example:
-         |$code
+         |$first
          |In this instance, the modifier 'sealed' is not applicable to the item type 'def' (method)
+         |$second
+         |In this instance, the modifier combination is not supported
         """
     }
   }

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -4,6 +4,8 @@ package reporting
 
 import core.Contexts.Context
 import diagnostic.messages._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Flags.FlagSet
 import dotty.tools.dotc.core.Types.WildcardType
 import dotty.tools.dotc.parsing.Tokens
 import org.junit.Assert._
@@ -841,14 +843,22 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       }
 
   @Test def modifiersNotAllowed =
-    checkMessagesAfter("refchecks")("""lazy trait T""")
+    verifyModifiersNotAllowed("lazy trait T", "lazy", Some("trait"))
+
+  @Test def modifiersOtherThanTraitMethodVariable =
+    verifyModifiersNotAllowed("sealed lazy class x", "sealed")
+
+  private def verifyModifiersNotAllowed(code: String, modifierAssertion: String,
+                                        typeAssertion: Option[String] = None) = {
+    checkMessagesAfter("refchecks")(code)
       .expect { (ictx, messages) =>
         implicit val ctx: Context = ictx
         assertMessageCount(1, messages)
         val ModifiersNotAllowed(flags, sort) :: Nil = messages
-        assertEquals("lazy", flags.toString)
-        assertEquals("trait", sort)
+        assertEquals(modifierAssertion, flags.toString)
+        assertEquals(typeAssertion, sort)
       }
+  }
 
   @Test def wildcardOnTypeArgumentNotAllowedOnNew =
     checkMessagesAfter("refchecks") {