Constructor proxy or companion is as protected as class

Require the constructor companion to be protected if the class is;
or create it protected. Otherwise, create protected proxies.

Author: som-snytt

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

@@ -110,8 +110,10 @@ object NamerOps:
    */
   def addConstructorApplies(scope: MutableScope, cls: ClassSymbol, modcls: ClassSymbol)(using Context): scope.type =
     def proxy(constr: Symbol): Symbol =
+      var flags = ApplyProxyFlags | (constr.flagsUNSAFE & AccessFlags)
+      if cls.is(Protected) && !modcls.is(Protected) then flags |= Protected
       newSymbol(
-        modcls, nme.apply, ApplyProxyFlags | (constr.flagsUNSAFE & AccessFlags),
+        modcls, nme.apply, flags,
         ApplyProxyCompleter(constr), coord = constr.coord)
     for dcl <- cls.info.decls do
       if dcl.isConstructor then scope.enter(proxy(dcl))
@@ -133,9 +135,11 @@ object NamerOps:
 
   /** A new symbol that is the constructor companion for class `cls` */
   def classConstructorCompanion(cls: ClassSymbol)(using Context): TermSymbol =
+    var flags = ConstructorCompanionFlags
+    if cls.is(Protected) then flags |= Protected
     val companion = newModuleSymbol(
         cls.owner, cls.name.toTermName,
-        ConstructorCompanionFlags, ConstructorCompanionFlags,
+        flags, flags,
         constructorCompanionCompleter(cls),
         coord = cls.coord,
         assocFile = cls.assocFile)

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

@@ -1111,9 +1111,8 @@ trait Applications extends Compatibility {
             //
             //    summonFrom {
             //      case given A[t] =>
-            //        summonFrom
+            //        summonFrom:
             //          case given `t` => ...
-            //        }
             //    }
             //
             // the second `summonFrom` should expand only once the first `summonFrom` is

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

@@ -3821,9 +3821,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           readapt(tree.appliedToNone) // insert () to primary constructors
         else
           errorTree(tree, em"Missing arguments for $methodStr")
-      case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
-        errorTree(tree, MethodDoesNotTakeParameters(tree))
-      }
+      case _ =>
+        tryInsertApplyOrImplicit(tree, pt, locked):
+          errorTree(tree, MethodDoesNotTakeParameters(tree))
     }
 
     def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {

tests/neg/i22560.scala

@@ -0,0 +1,22 @@
+
+class A:
+  protected class B
+
+// This fails to compile, as expected
+val x = A().B() // error
+
+object C:
+  protected val p = "protected"
+  protected def getString() = "Hello!"
+  protected class D:
+    def d = D() // ok
+
+// This fails to compile
+// val y = C.p
+
+// And this also fails to compile
+// val z = C.getString()
+
+// However, this compiles just fine.
+val alpha = C.D() // error
+val beta = new C.D() // error

tests/neg/i22560b.scala

@@ -0,0 +1,9 @@
+
+class Enumeration:
+  protected class Val(i: Int):
+    def this() = this(42)
+  object Val
+
+class Test extends Enumeration:
+  val Hearts = Val(27) // error
+  val Diamonds = Val() // error

tests/pos/i22560.scala

@@ -0,0 +1,22 @@
+
+package companionless:
+
+  class Enumeration:
+    protected class Val(i: Int):
+      def this() = this(42)
+
+  class Test extends Enumeration:
+    val Hearts = Val(27)
+    val Diamonds = Val()
+
+
+package companioned:
+
+  class Enumeration:
+    protected class Val(i: Int):
+      def this() = this(42)
+    protected object Val
+
+  class Test extends Enumeration:
+    val Hearts = Val(27)
+    val Diamonds = Val()