SI-7859 Value classes may wrap a non-public member

We allow value class constructors to be non-public, so to be regular,
we should also allow the same for the param accessor.

This commit uses the 'makeNotPrivate' machinery to ensure that
the backend can generate the requisite unboxing calls.

This commit:

  - refactors the code that enforced the restrictions, improving
    a few error messages and positions. The remaining restrictions
    needed some rewording in light of this change.
  - allows value classes to have non-public, val parameters.
    private[this] / protected[this] are still disallowed as value
    classes don't have a concept of `this`, and because trying to
    accomdate then would complicate the implementation.

    This means that `class C(x: Int) extends AnyVal` is not allowed,
    the user still must write `private val x: Int` or `val x: Int`.
  - Outlaw `class C()()(val x: Int) extends AnyVal` to curtail any
    bugs that might lurk in such a formulation.

The tests:

  - Show that the privacy is respected in the typer phase, under
    joint and separate compilation. We don't want a repeat performance
    of SI-6601.
  - Show that code that needs compiler-generated unboxes works under
    both compilation scenarios
  - Checks that the remaining restrictions are enforced and well
    communicated.

1 files changed, 3 insertions, 0 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 6a405295cf..a381019372 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -191,6 +191,9 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
             checkNonCyclic(currentOwner.pos, Set(), currentOwner) */
             extensionDefs(currentOwner.companionModule) = new mutable.ListBuffer[Tree]
             currentOwner.primaryConstructor.makeNotPrivate(NoSymbol)
+            // SI-7859 make param accessors accessible so the erasure can generate unbox operations.
+            val paramAccessors = currentOwner.info.decls.filter(sym => sym.isParamAccessor && sym.isMethod)
+            paramAccessors.foreach(_.makeNotPrivate(currentOwner))
             super.transform(tree)
           } else if (currentOwner.isStaticOwner) {
             super.transform(tree)