Warn for usage of open modifier on traits or classes where redundant

Fixes #11963

Author: megri

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

@@ -451,6 +451,14 @@ object desugar {
       }
       else originalTparams
 
+    if mods.is(Open) && (mods.isOneOf(AbstractOrTrait) || ctx.owner.is(Method)) then
+      val kind = 
+        if mods.is(Abstract) then RedundantModifierOwnerKind.AbstractClass
+        else if mods.is(Trait) then RedundantModifierOwnerKind.Trait
+        else RedundantModifierOwnerKind.LocalClass
+      val srcPos = mods.mods.find(_.flags == Open).get.srcPos
+      report.warning(ModifierRedundantFor(cdef, "open", kind), srcPos)
+
     if mods.is(Trait) then
       for vparams <- originalVparamss; vparam <- vparams do
         if vparam.tpt.isInstanceOf[ByNameTypeTree] then
@@ -865,10 +873,10 @@ object desugar {
     if (mods.is(Abstract))
       report.error(AbstractCannotBeUsedForObjects(mdef), flagSourcePos(Abstract))
     if (mods.is(Sealed))
-      report.error(ModifierRedundantForObjects(mdef, "sealed"), flagSourcePos(Sealed))
+      report.error(ModifierRedundantFor(mdef, "sealed", RedundantModifierOwnerKind.Module), flagSourcePos(Sealed))
     // Maybe this should be an error; see https://github.com/scala/bug/issues/11094.
     if (mods.is(Final) && !mods.is(Synthetic))
-      report.warning(ModifierRedundantForObjects(mdef, "final"), flagSourcePos(Final))
+      report.warning(ModifierRedundantFor(mdef, "final", RedundantModifierOwnerKind.Module), flagSourcePos(Final))
 
     if (mods.is(Package))
       packageModuleDef(mdef)

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

@@ -156,6 +156,7 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     EnumerationsShouldNotBeEmptyID,
     AbstractCannotBeUsedForObjectsID,
     ModifierRedundantForObjectsID,
+    ModifierRedundantForID,
     TypedCaseDoesNotExplicitlyExtendTypedEnumID,
     IllegalRedefinitionOfStandardKindID,
     NoExtensionMethodAllowedID,

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

@@ -2379,17 +2379,29 @@ import transform.SymUtils._
            |""".stripMargin
   }
 
-  class ModifierRedundantForObjects(mdef: untpd.ModuleDef, modifier: String)(using Context)
-    extends SyntaxMsg(ModifierRedundantForObjectsID) {
-    def msg = em"${hl(modifier)} modifier is redundant for objects"
-
-    def explain =
-      em"""|Objects cannot be extended making the ${hl(modifier)} modifier redundant.
-           |You may want to define the object without it:
-           | ${hl("object")} ${mdef.name} { }
+  enum RedundantModifierOwnerKind {
+    case AbstractClass, LocalClass, Module, Trait
+    def show: String = this match
+      case AbstractClass => "abstract class"
+      case LocalClass => "class"
+      case Module => "object"
+      case Trait => "trait"
+    def namePlural: String = this match
+      case AbstractClass => "abstract classes"
+      case LocalClass => "local classes"
+      case Module => "objects"
+      case Trait => "traits"
+  }
+
+  class ModifierRedundantFor(tree: untpd.NameTree, modifier: String, ownerKind: RedundantModifierOwnerKind)(using Context)
+    extends SyntaxMsg(ModifierRedundantForID) {
+    def msg = em"${hl(modifier)} modifier is redundant here"
+    def explain =
+      em"""|The modifier ${hl(modifier)} is redundant on ${ownerKind.namePlural}.
+           |You may want to define the ${ownerKind.show} without it:
+           | ${hl(ownerKind.show)} ${tree.name} { }
            |""".stripMargin
   }
-
   class TypedCaseDoesNotExplicitlyExtendTypedEnum(enumDef: Symbol, caseDef: untpd.TypeDef)(using Context)
     extends SyntaxMsg(TypedCaseDoesNotExplicitlyExtendTypedEnumID) {
     def msg = i"explicit extends clause needed because both enum case and enum class have type parameters"

tests/neg-custom-args/fatal-warnings/i11963a.scala

@@ -0,0 +1 @@
+open trait Foo // redundant modifier open

tests/neg-custom-args/fatal-warnings/i11963b.scala

@@ -0,0 +1 @@
+open abstract class Foo // redundant modifier open

tests/neg-custom-args/fatal-warnings/i11963c.scala

@@ -0,0 +1,6 @@
+object Test {
+  def foo: Any = {
+    open class Bar // redundant modifier open
+    new Bar
+  }
+}