[WIP] companion nest

src/compiler/scala/tools/nsc/Global.scala

@@ -1181,6 +1181,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
     keepPhaseStack = settings.log.isSetByUser
 
     val isScala3: Boolean = settings.isScala3: @nowarn
+    val isJDK11: Boolean = settings.releaseValue.map(_.toInt >= 11).getOrElse(false)
 
     object sourceFeatures {
       private val s = settings

src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala

@@ -711,13 +711,14 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
             generatedType = genPrimitiveOp(app, expectedType)
           } else { // normal method call
             def isTraitSuperAccessorBodyCall = app.hasAttachment[UseInvokeSpecial.type]
+            def isPrivateSpecial = sym.isPrivate && (claszSymbol.info <:< sym.owner.info)
             val invokeStyle =
               if (sym.isStaticMember)
                 InvokeStyle.Static
-              else if (sym.isPrivate || sym.isClassConstructor) InvokeStyle.Special
-              else if (isTraitSuperAccessorBodyCall)
+              else if (isPrivateSpecial || sym.isClassConstructor || isTraitSuperAccessorBodyCall)
                 InvokeStyle.Special
-              else InvokeStyle.Virtual
+              else
+                InvokeStyle.Virtual
 
             if (invokeStyle.hasInstance) genLoadQualifier(fun)
             genLoadArguments(args, paramTKs(app))

src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala

@@ -197,6 +197,11 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       if (emitSource) {
         cnode.visitSource(cunit.source.toString, null /* SourceDebugExtension */)
       }
+      if (currentRun.isJDK11 && claszSymbol.isModuleClass) {
+        val linked = claszSymbol.linkedClassOfClass
+        if (linked.exists)
+          cnode.visitNestHost(internalName(linked))
+      }
 
       enclosingMethodAttribute(claszSymbol, internalName, methodBTypeFromSymbol(_).descriptor) match {
         case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
@@ -208,6 +213,13 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       cnode.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
       emitAnnotations(cnode, claszSymbol.annotations ++ ssa)
 
+      if (currentRun.isJDK11 && !claszSymbol.isModuleClass) {
+        val companion = claszSymbol.companionModule
+        val linked = companion.moduleClass
+        if (linked.exists)
+          cnode.visitNestMember(internalName(linked))
+      }
+
       if (isCZStaticModule || isCZParcelable) {
 
         if (isCZStaticModule) { addModuleInstanceField() }

src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala

@@ -434,6 +434,10 @@ abstract class ExplicitOuter extends InfoTransform
           else atPos(tree.pos)(outerPath(outerValue, currentClass.outerClass, sym)) // (5)
 
         case Select(qual, name) =>
+          def isNestable(c0: Symbol, c1: Symbol): Boolean = currentRun.isJDK11 && (
+            (if (c0.isModuleClass) c0.linkedClassOfClass == c1 else c1.isModuleClass && c1.linkedClassOfClass == c0)
+            || c0.hasTransOwner(c1)
+          )
           // make not private symbol accessed from inner classes, as well as
           // symbols accessed from @inline methods
           //
@@ -442,7 +446,7 @@ abstract class ExplicitOuter extends InfoTransform
           def enclMethodIsInline = closestEnclMethod(currentOwner) hasAnnotation ScalaInlineClass
           // scala/bug#8710 The extension method condition reflects our knowledge that a call to `new Meter(12).privateMethod`
           //         with later be rewritten (in erasure) to `Meter.privateMethod$extension(12)`.
-          if ((currentClass != sym.owner || enclMethodIsInline) && !sym.isMethodWithExtension)
+          if ((currentClass != sym.owner || enclMethodIsInline) && !sym.isMethodWithExtension && !isNestable(currentClass, sym.owner))
             sym.makeNotPrivate(sym.owner)
 
           val qsym = qual.tpe.widen.typeSymbol

test/files/run/t6882.scala

@@ -0,0 +1,15 @@
+//> using options --release:11
+
+class C(private val i: Int, private val j: Int) {
+  private val c = i + C.secret
+
+  @inline def f = j * 2
+}
+object C {
+  def unwrap(c: C): Int = c.c
+
+  private def secret = 5
+}
+object Test extends App {
+  assert(C.unwrap(new C(42, 27)) == 47)
+}