Add marker trait for polymorphic function types

This is the only trait that can be refined with a polymorphic method,
as long as that method is called `apply`, e.g.:
    PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R }
This type will be erased to FunctionN.

Author: smarter

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

@@ -882,6 +882,9 @@ class Definitions {
     if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
     else FunctionClass(n, isImplicit, isErased).typeRef
 
+  lazy val PolyFunctionClass = ctx.requiredClass("scala.PolyFunction")
+  def PolyFunctionType = PolyFunctionClass.typeRef
+
   private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
 
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */

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

@@ -353,6 +353,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *      - otherwise, if T is a type paramter coming from Java, []Object
    *      - otherwise, Object
    *   - For a term ref p.x, the type <noprefix> # x.
+   *   - For a refined type scala.PolyFunction { def apply[...](x_1, ..., x_N): R }, scala.FunctionN
    *   - For a typeref scala.Any, scala.AnyVal or scala.Singleton: |java.lang.Object|
    *   - For a typeref scala.Unit, |scala.runtime.BoxedUnit|.
    *   - For a typeref scala.FunctionN, where N > MaxImplementedFunctionArity, scala.FunctionXXL
@@ -397,6 +398,12 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       SuperType(this(thistpe), this(supertpe))
     case ExprType(rt) =>
       defn.FunctionType(0)
+    case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
+      assert(refinedInfo.isInstanceOf[PolyType])
+      val res = refinedInfo.resultType
+      val paramss = res.paramNamess
+      assert(paramss.length == 1)
+      this(defn.FunctionType(paramss.head.length, isImplicit = res.isImplicitMethod, isErased = res.isErasedMethod))
     case tp: TypeProxy =>
       this(tp.underlying)
     case AndType(tp1, tp2) =>

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

@@ -378,21 +378,26 @@ object Erasure {
      */
     override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
 
+      val qual1 = typed(tree.qualifier, AnySelectionProto)
+
       def mapOwner(sym: Symbol): Symbol = {
-        def recur(owner: Symbol): Symbol =
-          if ((owner eq defn.AnyClass) || (owner eq defn.AnyValClass)) {
-            assert(sym.isConstructor, s"${sym.showLocated}")
-            defn.ObjectClass
-          } else if (defn.isSyntheticFunctionClass(owner))
-            defn.erasedFunctionClass(owner)
-          else
-            owner
-        recur(sym.owner)
+        val owner = sym.maybeOwner
+        if (!owner.exists) {
+          // Hack for PolyFunction#apply
+          qual1.tpe.widen.typeSymbol
+        } else if ((owner eq defn.AnyClass) || (owner eq defn.AnyValClass)) {
+          assert(sym.isConstructor, s"${sym.showLocated}")
+          defn.ObjectClass
+        } else if (defn.isSyntheticFunctionClass(owner)) {
+          defn.erasedFunctionClass(owner)
+        }
+        else
+          owner
       }
 
       val origSym = tree.symbol
       val owner = mapOwner(origSym)
-      val sym = if (owner eq origSym.owner) origSym else owner.info.decl(origSym.name).symbol
+      val sym = if (owner eq origSym.maybeOwner) origSym else owner.info.decl(tree.name).symbol
       assert(sym.exists, origSym.showLocated)
 
       def select(qual: Tree, sym: Symbol): Tree =
@@ -436,7 +441,7 @@ object Erasure {
         }
       }
 
-      recur(typed(tree.qualifier, AnySelectionProto))
+      recur(qual1)
     }
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =

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

@@ -1200,7 +1200,9 @@ class Typer extends Namer
       typr.println(s"adding refinement $refinement")
       checkRefinementNonCyclic(refinement, refineCls, seen)
       val rsym = refinement.symbol
-      if (rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
+      val polymorphicRefinementAllowed =
+        tpt1.tpe.typeSymbol == defn.PolyFunctionClass && rsym.name == nme.apply
+      if (!polymorphicRefinementAllowed && rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
         ctx.error(PolymorphicMethodMissingTypeInParent(rsym, tpt1.symbol), refinement.pos)
     }
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)

library/src/scala/PolyFunction.scala

@@ -0,0 +1,10 @@
+package scala
+
+/** Marker trait for polymorphic function types.
+ *
+ *  This is the only trait that can be refined with a polymorphic method,
+ *  as long as that method is called `apply`, e.g.:
+ *      PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R }
+ *  This type will be erased to FunctionN.
+ */
+trait PolyFunction

tests/run/polymorphic-functions.scala

@@ -0,0 +1,9 @@
+object Test {
+  def test1(f: PolyFunction { def apply[T <: AnyVal](x: List[T]): List[(T, T)] }) = {
+    f(List(1, 2, 3))
+  }
+
+  def main(args: Array[String]): Unit = {
+    //test1(...)
+  }
+}