Better recovery from parsing errors in local statements

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

@@ -624,4 +624,6 @@ object Flags {
   val SyntheticParam: FlagSet                = Synthetic | Param
   val SyntheticTermParam: FlagSet            = Synthetic | TermParam
   val SyntheticTypeParam: FlagSet            = Synthetic | TypeParam
+
+  val NonAllowedLocalModifier: FlagSet       = Private | Abstract  //| Final | Sealed | Implicit | Lazy
 }

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

@@ -4709,7 +4709,7 @@ object Parsers {
     }
 
     def localDef(start: Int, implicitMods: Modifiers = EmptyModifiers): Tree = {
-      var mods = defAnnotsMods(localModifierTokens)
+      var mods = defAnnotsMods(modifierTokens)
       for (imod <- implicitMods.mods) mods = addMod(mods, imod)
       if (mods.is(Final))
         // A final modifier means the local definition is "class-like".  // FIXME: Deal with modifiers separately
@@ -4726,7 +4726,7 @@ object Parsers {
 
     /** BlockStatSeq ::= { BlockStat semi } [Expr]
      *  BlockStat    ::= Import
-     *                 | Annotations [implicit] [lazy] Def
+     *                 | Annotations [implicit] [lazy] ValOrDef
      *                 | Annotations LocalModifiers TmplDef
      *                 | Extension
      *                 | Expr1
@@ -4744,7 +4744,7 @@ object Parsers {
           stats += closure(in.offset, Location.InBlock, modifiers(BitSet(IMPLICIT)))
         else if isIdent(nme.extension) && followingIsExtension() then
           stats += extension()
-        else if isDefIntro(localModifierTokens,
+        else if isDefIntro(modifierTokens,
             excludedSoftModifiers =
               // Allow opaque definitions at outermost level in REPL.
               if outermost && ctx.mode.is(Mode.Interactive)

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

@@ -591,6 +591,10 @@ object Checking {
       checkWithDeferred(Private)
       checkWithDeferred(Final)
     }
+
+    if !sym.owner.isClass && sym.is(Method) && sym.isOneOf(NonAllowedLocalModifier) then
+        report.error("not allowed", sym.srcPos)
+
     if (sym.isValueClass && sym.is(Trait) && !sym.isRefinementClass)
       fail(CannotExtendAnyVal(sym))
     if (sym.isConstructor && !sym.isPrimaryConstructor && sym.owner.is(Trait, butNot = JavaDefined))

tests/neg/i22631.check

@@ -0,0 +1,16 @@
+-- Error: tests/neg/i22631.scala:3:16 ----------------------------------------------------------------------------------
+3 |    private def bar: Int = 0 // error
+  |                ^
+  |                not allowed
+-- Error: tests/neg/i22631.scala:8:16 ----------------------------------------------------------------------------------
+8 |    private def bar: Int = 0 // error
+  |                ^
+  |                not allowed
+-- Error: tests/neg/i22631.scala:13:16 ---------------------------------------------------------------------------------
+13 |    private def bar: Int = 0 // error
+   |                ^
+   |                not allowed
+-- Error: tests/neg/i22631.scala:18:16 ---------------------------------------------------------------------------------
+18 |    private def bar: Int = 0 // error
+   |                ^
+   |                not allowed

tests/neg/i22631.scala

@@ -0,0 +1,20 @@
+object Foo:
+  def foo1: Int = {
+    private def bar: Int = 0 // error
+    bar
+  }
+
+  def foo2: Int = {
+    private def bar: Int = 0 // error
+    bar
+  }
+
+  def foo3: Int = {
+    private def bar: Int = 0 // error
+    bar
+  }
+
+  def foo4: Int = {
+    private def bar: Int = 0 // error
+    bar
+  }