Change private local inference to allow inferring private local for private vals constructor parameters

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

@@ -2658,11 +2658,9 @@ object SymDenotations {
    *  This holds for all symbols except
    *   - constructors, since they can never be referred to as members of their
    *     own, fully elaborated `this`.
-   *   - parameters and parameter accessors, since their Local status is already
-   *     determined by whether they have a `val` or `var` or not.
    */
   def canBeLocal(name: Name, flags: FlagSet)(using Context) =
-    !name.isConstructorName && !flags.is(Param) && !flags.is(ParamAccessor)
+    !name.isConstructorName
 
   /** Factory method for SymDenotion creation. All creations
    *  should be done via this method.

tests/init/crash/rbtree.scala

@@ -439,18 +439,18 @@ object RedBlackTree {
     def black: Tree[A, B]
     def red: Tree[A, B]
   }
-  final class RedTree[A, +B](key: A,
-                             value: B,
-                             left: Tree[A, B],
-                             right: Tree[A, B]) extends Tree[A, B](key, value, left, right) {
+  final class RedTree[A, +B](_key: A,
+                             _value: B,
+                             _left: Tree[A, B],
+                             _right: Tree[A, B]) extends Tree[A, B](_key, _value, _left, _right) {
     override def black: Tree[A, B] = BlackTree(key, value, left, right)
     override def red: Tree[A, B] = this
     override def toString: String = "RedTree(" + key + ", " + value + ", " + left + ", " + right + ")"
   }
-  final class BlackTree[A, +B](key: A,
-                               value: B,
-                               left: Tree[A, B],
-                               right: Tree[A, B]) extends Tree[A, B](key, value, left, right) {
+  final class BlackTree[A, +B](_key: A,
+                               _value: B,
+                               _left: Tree[A, B],
+                               _right: Tree[A, B]) extends Tree[A, B](_key, _value, _left, _right) {
     override def black: Tree[A, B] = this
     override def red: Tree[A, B] = RedTree(key, value, left, right)
     override def toString: String = "BlackTree(" + key + ", " + value + ", " + left + ", " + right + ")"

tests/pos/extend-java-enum.scala

@@ -2,8 +2,8 @@
 
 import java.{lang as jl}
 
-final class ConfigSyntax private (name: String, ordinal: Int)
-  extends jl.Enum[ConfigSyntax](name, ordinal)
+final class ConfigSyntax private (_name: String, ordinal: Int)
+  extends jl.Enum[ConfigSyntax](_name, ordinal)
 
 object ConfigSyntax {
 

tests/pos/i22620.scala

@@ -0,0 +1,5 @@
+import scala.collection.mutable.ArrayBuffer
+
+class PrivateTest[-M](private val v: ArrayBuffer[M])
+
+class PrivateTest1[-M](v: ArrayBuffer[M])

tests/pos/private-local-override-1.scala

@@ -0,0 +1,11 @@
+sealed abstract class Tree[+A](
+  final val key: A
+)
+final class RedTree[+A](private val _key: A) extends Tree[A](_key)
+final class BlackTree[+A](private val _key: A) extends Tree[A](_key)
+object RedTree {
+  def unapply[A](t: RedTree[A]) = Some((t.key))
+}
+object BlackTree {
+  def unapply[A](t: BlackTree[A]) = Some((t.key))
+}

tests/pos/private-local-override.scala

@@ -0,0 +1,11 @@
+sealed abstract class Tree[+A](
+  final val key: A
+)
+final class RedTree[+A](_key: A) extends Tree[A](_key)
+final class BlackTree[+A](_key: A) extends Tree[A](_key)
+object RedTree {
+  def unapply[A](t: RedTree[A]) = Some((t.key))
+}
+object BlackTree {
+  def unapply[A](t: BlackTree[A]) = Some((t.key))
+}

tests/pos/rbtree.scala

@@ -439,18 +439,18 @@ object RedBlackTree {
     def black: Tree[A, B]
     def red: Tree[A, B]
   }
-  final class RedTree[A, +B](key: A,
-                             value: B,
-                             left: Tree[A, B],
-                             right: Tree[A, B]) extends Tree[A, B](key, value, left, right) {
+  final class RedTree[A, +B](_key: A,
+                             _value: B,
+                             _left: Tree[A, B],
+                             _right: Tree[A, B]) extends Tree[A, B](_key, _value, _left, _right) {
     override def black: Tree[A, B] = BlackTree(key, value, left, right)
     override def red: Tree[A, B] = this
     override def toString: String = "RedTree(" + key + ", " + value + ", " + left + ", " + right + ")"
   }
-  final class BlackTree[A, +B](key: A,
-                               value: B,
-                               left: Tree[A, B],
-                               right: Tree[A, B]) extends Tree[A, B](key, value, left, right) {
+  final class BlackTree[A, +B](_key: A,
+                               _value: B,
+                               _left: Tree[A, B],
+                               _right: Tree[A, B]) extends Tree[A, B](_key, _value, _left, _right) {
     override def black: Tree[A, B] = this
     override def red: Tree[A, B] = RedTree(key, value, left, right)
     override def toString: String = "BlackTree(" + key + ", " + value + ", " + left + ", " + right + ")"

tests/warn/i15503c.scala

@@ -36,7 +36,7 @@ package foo.test.constructors:
   case class A private (x: Int) // OK
   class B private (val x: Int) // OK
   object B { def default = B(42) }
-  class C private (private val xy: Int) // warn
+  class C private (private val xy: Int)
   object C { def default = C(42) }
   class D private (private val x: Int): // OK
     def y = x