Fix 4815: Illegal modifier on local def

During typechecking, disallow the use of "final" in local "defs".

e.g.

def foo = {
  final def bar = 42 // error: final in local def is disallowed
}

Author: abeln

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -131,6 +131,7 @@ public enum ErrorMessageID {
     MatchCaseOnlyNullWarningID,
     ImportRenamedTwiceID,
     TypeTestAlwaysSucceedsID,
+    LocalDefMayNotBeFinalID,
     ;
 
     public int errorNumber() {

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

@@ -1560,6 +1560,15 @@ object messages {
       "A trait can never be final since it is abstract and must be extended to be useful."
   }
 
+  case class LocalDefMayNotBeFinal(sym: Symbol)(
+    implicit ctx: Context)
+    extends Message(LocalDefMayNotBeFinalID) {
+    val msg = hl"""$sym may not be ${"final"}."""
+    val kind = "Syntax"
+    val explanation =
+      hl"Only ${"def"}s that appear as fields may be marked as ${"final"}, but $sym is a local definition."
+  }
+
   case class NativeMembersMayNotHaveImplementation(sym: Symbol)(
     implicit ctx: Context)
     extends Message(NativeMembersMayNotHaveImplementationID) {

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

@@ -369,6 +369,8 @@ object Checking {
       if (!ok && !sym.is(Synthetic))
         fail(i"modifier `$flag` is not allowed for this definition")
 
+    def isClassLike(sym: Symbol) = sym.isClass || sym.is(Module) || sym.isAnonymousClass
+
     if (sym.is(Transparent) &&
           (  sym.is(ParamAccessor) && sym.owner.isClass
           || sym.is(TermParam) && !sym.owner.isTransparentMethod
@@ -387,6 +389,9 @@ object Checking {
       fail(AbstractOverrideOnlyInTraits(sym))
     if (sym.is(Trait) && sym.is(Final))
       fail(TraitsMayNotBeFinal(sym))
+    if (sym.is(Method) && sym.is(Final) && !isClassLike(sym.owner)) {
+      fail(LocalDefMayNotBeFinal(sym))
+    }
     // Skip ModuleVal since the annotation will also be on the ModuleClass
     if (sym.hasAnnotation(defn.TailrecAnnot) && !sym.is(Method | ModuleVal))
       fail(TailrecNotApplicable(sym))

tests/neg/t4815.scala

@@ -0,0 +1,24 @@
+class Test {
+  def foo = {
+    final def bar = 1 // error: local def may not be final
+    final val v = 42 // ok: this is a constant expression
+  }
+
+  {
+    final def foo(x: Int) = x // error: local def may not be final
+  }
+
+  final def foo2(x: Int) = x // ok: final allowed in class field
+
+  object Foo {
+    final def foo(x: Int) = x // ok, but redundant
+  }
+
+  abstract class Bar {
+    def foo: Int
+  }
+
+  val x = new Bar {
+    override final def foo = 42 // ok: def is a field
+  }
+}