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

@@ -1035,6 +1035,11 @@ class Definitions {
     if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
     else FunctionClass(n, isContextual, 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 */
   def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =
     if (cls.isClass && cls.owner == ScalaPackageClass) cls.asClass.name else EmptyTypeName

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

@@ -383,6 +383,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *      - otherwise, if T is a type parameter 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, scala.Singleton, scala.Tuple, or scala.*: : |java.lang.Object|
    *   - For a typeref scala.Unit, |scala.runtime.BoxedUnit|.
    *   - For a typeref scala.FunctionN, where N > MaxImplementedFunctionArity, scala.FunctionXXL
@@ -429,6 +430,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, isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
     case tp: TypeProxy =>
       this(tp.underlying)
     case AndType(tp1, tp2) =>

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

@@ -416,21 +416,28 @@ 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 (defn.specialErasure.contains(owner)) {
+        def recur(owner: Symbol): Symbol = {
+          val owner = sym.maybeOwner
+          if (!owner.exists) {
+            // Hack for PolyFunction#apply
+            qual1.tpe.widen.typeSymbol
+          } else if (defn.specialErasure.contains(owner)) {
             assert(sym.isConstructor, s"${sym.showLocated}")
             defn.specialErasure(owner)
           } else if (defn.isSyntheticFunctionClass(owner))
             defn.erasedFunctionClass(owner)
           else
             owner
-        recur(sym.owner)
+        }
+        recur(sym.maybeOwner)
       }
 
       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 =
@@ -474,7 +481,7 @@ object Erasure {
         }
       }
 
-      checkNotErased(recur(typed(tree.qualifier, AnySelectionProto)))
+      checkNotErased(recur(qual1))
     }
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =

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

@@ -1271,7 +1271,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.sourcePos)
 
       val member = refineCls.info.member(rsym.name)

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(...)
+  }
+}