Disallow extending PolyFunction in user code (#18920)

The `PolyFunction` trait should only be used for compiler generated
encoded lambdas.

Any other use case that was allowed before was accidental. In the
future,
we might consider supporting these if there is a good use case. This
would
probably require a SIP.

Fixes #10075

Author: smarter

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -370,6 +370,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           val callTrace = ref(call.symbol)(using ctx.withSource(pos.source)).withSpan(pos.span)
           cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(tree)))
         case templ: Template =>
+          Checking.checkPolyFunctionExtension(templ)
           withNoCheckNews(templ.parents.flatMap(newPart)) {
             forwardParamAccessors(templ)
             synthMbr.addSyntheticMembers(

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

@@ -845,6 +845,14 @@ object Checking {
     def reportNoRefinements(pos: SrcPos) =
       report.error("PolyFunction subtypes must refine the apply method", pos)
   }.traverse(tree)
+
+  /** Check that users do not extend the `PolyFunction` trait.
+   *  We only allow compiler generated `PolyFunction`s.
+   */
+  def checkPolyFunctionExtension(templ: Template)(using Context): Unit =
+    templ.parents.find(_.tpe.derivesFrom(defn.PolyFunctionClass)) match
+      case Some(parent) => report.error(s"`PolyFunction` marker trait is reserved for compiler generated refinements", parent.srcPos)
+      case None =>
 }
 
 trait Checking {

tests/run/erased-15.scala renamed to tests/neg/erased-15.scala

@@ -12,7 +12,7 @@ object Test {
   }
 }
 
-class Foo extends PolyFunction {
+class Foo extends PolyFunction { // error
   def apply(erased x: Int): Int = {
     println("Foo.apply")
     42

tests/neg/i10075.check

@@ -0,0 +1,32 @@
+-- Error: tests/neg/i10075.scala:8:24 ----------------------------------------------------------------------------------
+8 |trait PolyTrait extends PolyFunction // error
+  |                        ^^^^^^^^^^^^
+  |                        `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:10:24 ---------------------------------------------------------------------------------
+10 |class PolyClass extends PolyTrait { // error
+   |                        ^^^^^^^^^
+   |                        `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:14:26 ---------------------------------------------------------------------------------
+14 |object PolyObject extends PolyFunction // error
+   |                          ^^^^^^^^^^^^
+   |                          `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:2:14 ----------------------------------------------------------------------------------
+2 |val foo = new PolyFunction { } // error
+  |              ^^^^^^^^^^^^
+  |              `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:3:14 ----------------------------------------------------------------------------------
+3 |val bar = new PolyFunction { def bar = 23 } // error
+  |              ^^^^^^^^^^^^
+  |              `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:4:14 ----------------------------------------------------------------------------------
+4 |val baz = new PolyFunction { def apply = 23 } // error
+  |              ^^^^^^^^^^^^
+  |              `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:5:14 ----------------------------------------------------------------------------------
+5 |val qux = new PolyFunction { def apply[T] = 47 } // error
+  |              ^^^^^^^^^^^^
+  |              `PolyFunction` marker trait is reserved for compiler generated refinements
+-- Error: tests/neg/i10075.scala:6:15 ----------------------------------------------------------------------------------
+6 |val quxx = new PolyFunction { def apply[T](x: T): T = x } // error
+  |               ^^^^^^^^^^^^
+  |               `PolyFunction` marker trait is reserved for compiler generated refinements

tests/neg/i10075.scala

@@ -0,0 +1,14 @@
+val poly = [T] => (x: T) => x
+val foo = new PolyFunction { } // error
+val bar = new PolyFunction { def bar = 23 } // error
+val baz = new PolyFunction { def apply = 23 } // error
+val qux = new PolyFunction { def apply[T] = 47 } // error
+val quxx = new PolyFunction { def apply[T](x: T): T = x } // error
+
+trait PolyTrait extends PolyFunction // error
+
+class PolyClass extends PolyTrait { // error
+  def apply[T](x: T): T = x
+}
+
+object PolyObject extends PolyFunction // error

tests/neg/i10369.scala

@@ -0,0 +1,10 @@
+type Upgrade[T] = T match
+  case Int => Double
+  case Char => String
+  case Boolean => Boolean
+
+val upgrade: [t] => t => Upgrade[t] = new PolyFunction: // error
+  def apply[T](x: T): Upgrade[T] = x match
+    case x: Int => x.toDouble
+    case x: Char => x.toString
+    case x: Boolean => !x

tests/pos/i18302a.scala renamed to tests/neg/i18302a.scala

@@ -1,4 +1,4 @@
 def test = polyFun(1)
 
 def polyFun: PolyFunction { def apply(x: Int): Int } =
-  new PolyFunction { def apply(x: Int): Int = x + 1 }
+  new PolyFunction { def apply(x: Int): Int = x + 1 } // error

tests/neg/i18302b.check

@@ -2,3 +2,7 @@
 3 |def polyFun: PolyFunction { def apply(x: Int)(y: Int): Int } = // error
   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |Implementation restriction: PolyFunction apply must have exactly one parameter list and optionally type arguments. No by-name nor varags are allowed.
+-- Error: tests/neg/i18302b.scala:4:6 ----------------------------------------------------------------------------------
+4 |  new PolyFunction: // error
+  |      ^^^^^^^^^^^^
+  |      `PolyFunction` marker trait is reserved for compiler generated refinements

tests/neg/i18302b.scala

@@ -1,5 +1,5 @@
 def test = polyFun(1)(2)
 
 def polyFun: PolyFunction { def apply(x: Int)(y: Int): Int } = // error
-  new PolyFunction:
+  new PolyFunction: // error
     def apply(x: Int)(y: Int): Int = x + y

tests/neg/i18302c.check

@@ -2,3 +2,7 @@
 4 |def polyFun: PolyFunction { def foo(x: Int): Int } = // error
   |                            ^^^^^^^^^^^^^^^^^^^^
   |                            PolyFunction only supports apply method refinements
+-- Error: tests/neg/i18302c.scala:5:6 ----------------------------------------------------------------------------------
+5 |  new PolyFunction { def foo(x: Int): Int = x + 1 } // error
+  |      ^^^^^^^^^^^^
+  |      `PolyFunction` marker trait is reserved for compiler generated refinements